Moving charon to libcharon.
[strongswan.git] / src / libcharon / encoding / parser.c
1 /*
2 * Copyright (C) 2005-2009 Martin Willi
3 * Copyright (C) 2005 Jan Hutter
4 * Hochschule fuer Technik Rapperswil
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * for more details.
15 */
16
17 #include <stdlib.h>
18 #include <arpa/inet.h>
19 #include <string.h>
20
21 #include "parser.h"
22
23 #include <library.h>
24 #include <daemon.h>
25 #include <utils/linked_list.h>
26 #include <encoding/payloads/encodings.h>
27 #include <encoding/payloads/payload.h>
28 #include <encoding/payloads/sa_payload.h>
29 #include <encoding/payloads/proposal_substructure.h>
30 #include <encoding/payloads/transform_substructure.h>
31 #include <encoding/payloads/transform_attribute.h>
32 #include <encoding/payloads/ke_payload.h>
33 #include <encoding/payloads/nonce_payload.h>
34 #include <encoding/payloads/id_payload.h>
35 #include <encoding/payloads/notify_payload.h>
36 #include <encoding/payloads/encryption_payload.h>
37 #include <encoding/payloads/auth_payload.h>
38 #include <encoding/payloads/cert_payload.h>
39 #include <encoding/payloads/certreq_payload.h>
40 #include <encoding/payloads/ts_payload.h>
41 #include <encoding/payloads/delete_payload.h>
42 #include <encoding/payloads/vendor_id_payload.h>
43 #include <encoding/payloads/cp_payload.h>
44 #include <encoding/payloads/configuration_attribute.h>
45 #include <encoding/payloads/eap_payload.h>
46 #include <encoding/payloads/unknown_payload.h>
47
48
49 typedef struct private_parser_t private_parser_t;
50
51 /**
52 * Private data stored in a context.
53 *
54 * Contains pointers and counters to store current state.
55 */
56 struct private_parser_t {
57 /**
58 * Public members, see parser_t.
59 */
60 parser_t public;
61
62 /**
63 * Current bit for reading in input data.
64 */
65 u_int8_t bit_pos;
66
67 /**
68 * Current byte for reading in input data.
69 */
70 u_int8_t *byte_pos;
71
72 /**
73 * Input data to parse.
74 */
75 u_int8_t *input;
76
77 /**
78 * Roof of input, used for length-checking.
79 */
80 u_int8_t *input_roof;
81
82 /**
83 * Set of encoding rules for this parsing session.
84 */
85 encoding_rule_t *rules;
86 };
87
88 /**
89 * Forward declaration
90 */
91 static status_t parse_payload(private_parser_t *this,
92 payload_type_t payload_type, payload_t **payload);
93
94 /**
95 * Log invalid length error
96 */
97 static bool short_input(private_parser_t *this, int number)
98 {
99 DBG1(DBG_ENC, " not enough input to parse rule %d %N",
100 number, encoding_type_names, this->rules[number].type);
101 return FALSE;
102 }
103
104 /**
105 * Log unaligned rules
106 */
107 static bool bad_bitpos(private_parser_t *this, int number)
108 {
109 DBG1(DBG_ENC, " found rule %d %N on bitpos %d",
110 number, encoding_type_names, this->rules[number].type, this->bit_pos);
111 return FALSE;
112 }
113
114 /**
115 * Parse a 4-Bit unsigned integer from the current parsing position.
116 */
117 static bool parse_uint4(private_parser_t *this, int rule_number,
118 u_int8_t *output_pos)
119 {
120 if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
121 {
122 return short_input(this, rule_number);
123 }
124 switch (this->bit_pos)
125 {
126 case 0:
127 if (output_pos)
128 {
129 *output_pos = *(this->byte_pos) >> 4;
130 }
131 this->bit_pos = 4;
132 break;
133 case 4:
134 if (output_pos)
135 {
136 *output_pos = *(this->byte_pos) & 0x0F;
137 }
138 this->bit_pos = 0;
139 this->byte_pos++;
140 break;
141 default:
142 return bad_bitpos(this, rule_number);
143 }
144 if (output_pos)
145 {
146 DBG3(DBG_ENC, " => %d", *output_pos);
147 }
148 return TRUE;
149 }
150
151 /**
152 * Parse a 8-Bit unsigned integer from the current parsing position.
153 */
154 static bool parse_uint8(private_parser_t *this, int rule_number,
155 u_int8_t *output_pos)
156 {
157 if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
158 {
159 return short_input(this, rule_number);
160 }
161 if (this->bit_pos)
162 {
163 return bad_bitpos(this, rule_number);
164 }
165 if (output_pos)
166 {
167 *output_pos = *(this->byte_pos);
168 DBG3(DBG_ENC, " => %d", *output_pos);
169 }
170 this->byte_pos++;
171 return TRUE;
172 }
173
174 /**
175 * Parse a 15-Bit unsigned integer from the current parsing position.
176 */
177 static bool parse_uint15(private_parser_t *this, int rule_number,
178 u_int16_t *output_pos)
179 {
180 if (this->byte_pos + sizeof(u_int16_t) > this->input_roof)
181 {
182 return short_input(this, rule_number);
183 }
184 if (this->bit_pos != 1)
185 {
186 return bad_bitpos(this, rule_number);
187 }
188 if (output_pos)
189 {
190 memcpy(output_pos, this->byte_pos, sizeof(u_int16_t));
191 *output_pos = ntohs(*output_pos) & ~0x8000;
192 DBG3(DBG_ENC, " => %d", *output_pos);
193 }
194 this->byte_pos += sizeof(u_int16_t);
195 this->bit_pos = 0;
196 return TRUE;
197 }
198
199 /**
200 * Parse a 16-Bit unsigned integer from the current parsing position.
201 */
202 static bool parse_uint16(private_parser_t *this, int rule_number,
203 u_int16_t *output_pos)
204 {
205 if (this->byte_pos + sizeof(u_int16_t) > this->input_roof)
206 {
207 return short_input(this, rule_number);
208 }
209 if (this->bit_pos)
210 {
211 return bad_bitpos(this, rule_number);
212 }
213 if (output_pos)
214 {
215 memcpy(output_pos, this->byte_pos, sizeof(u_int16_t));
216 *output_pos = ntohs(*output_pos);
217 DBG3(DBG_ENC, " => %d", *output_pos);
218 }
219 this->byte_pos += sizeof(u_int16_t);
220 return TRUE;
221 }
222 /**
223 * Parse a 32-Bit unsigned integer from the current parsing position.
224 */
225 static bool parse_uint32(private_parser_t *this, int rule_number,
226 u_int32_t *output_pos)
227 {
228 if (this->byte_pos + sizeof(u_int32_t) > this->input_roof)
229 {
230 return short_input(this, rule_number);
231 }
232 if (this->bit_pos)
233 {
234 return bad_bitpos(this, rule_number);
235 }
236 if (output_pos)
237 {
238 memcpy(output_pos, this->byte_pos, sizeof(u_int32_t));
239 *output_pos = ntohl(*output_pos);
240 DBG3(DBG_ENC, " => %d", *output_pos);
241 }
242 this->byte_pos += sizeof(u_int32_t);
243 return TRUE;
244 }
245
246 /**
247 * Parse a given amount of bytes and writes them to a specific location
248 */
249 static bool parse_bytes(private_parser_t *this, int rule_number,
250 u_int8_t *output_pos, int bytes)
251 {
252 if (this->byte_pos + bytes > this->input_roof)
253 {
254 return short_input(this, rule_number);
255 }
256 if (this->bit_pos)
257 {
258 return bad_bitpos(this, rule_number);
259 }
260 if (output_pos)
261 {
262 memcpy(output_pos, this->byte_pos, bytes);
263 DBG3(DBG_ENC, " => %b", output_pos, bytes);
264 }
265 this->byte_pos += bytes;
266 return TRUE;
267 }
268
269 /**
270 * Parse a single Bit from the current parsing position
271 */
272 static bool parse_bit(private_parser_t *this, int rule_number,
273 bool *output_pos)
274 {
275 if (this->byte_pos + sizeof(u_int8_t) > this->input_roof)
276 {
277 return short_input(this, rule_number);
278 }
279 if (output_pos)
280 {
281 u_int8_t mask;
282 mask = 0x01 << (7 - this->bit_pos);
283 *output_pos = *this->byte_pos & mask;
284
285 if (*output_pos)
286 { /* set to a "clean", comparable true */
287 *output_pos = TRUE;
288 }
289 DBG3(DBG_ENC, " => %d", *output_pos);
290 }
291 this->bit_pos = (this->bit_pos + 1) % 8;
292 if (this->bit_pos == 0)
293 {
294 this->byte_pos++;
295 }
296 return TRUE;
297 }
298
299 /**
300 * Parse substructures in a list.
301 */
302 static bool parse_list(private_parser_t *this, int rule_number,
303 linked_list_t **output_pos, payload_type_t payload_type, int length)
304 {
305 linked_list_t *list = *output_pos;
306
307 if (length < 0)
308 {
309 return short_input(this, rule_number);
310 }
311 if (this->bit_pos)
312 {
313 return bad_bitpos(this, rule_number);
314 }
315 while (length > 0)
316 {
317 u_int8_t *pos_before = this->byte_pos;
318 payload_t *payload;
319
320 DBG2(DBG_ENC, " %d bytes left, parsing recursively %N",
321 length, payload_type_names, payload_type);
322
323 if (parse_payload(this, payload_type, &payload) != SUCCESS)
324 {
325 DBG1(DBG_ENC, " parsing of a %N substructure failed",
326 payload_type_names, payload_type);
327 return FALSE;
328 }
329 list->insert_last(list, payload);
330 length -= this->byte_pos - pos_before;
331 }
332 if (length != 0)
333 { /* must yield exactly to zero */
334 DBG1(DBG_ENC, " length of %N substructure list invalid",
335 payload_type_names, payload_type);
336 return FALSE;
337 }
338 *output_pos = list;
339 return TRUE;
340 }
341
342 /**
343 * Parse data from current parsing position in a chunk.
344 */
345 static bool parse_chunk(private_parser_t *this, int rule_number,
346 chunk_t *output_pos, int length)
347 {
348 if (this->byte_pos + length > this->input_roof)
349 {
350 return short_input(this, rule_number);
351 }
352 if (this->bit_pos)
353 {
354 return bad_bitpos(this, rule_number);
355 }
356 if (output_pos)
357 {
358 *output_pos = chunk_alloc(length);
359 memcpy(output_pos->ptr, this->byte_pos, length);
360 DBG3(DBG_ENC, " => %b", output_pos->ptr, length);
361 }
362 this->byte_pos += length;
363 return TRUE;
364 }
365
366 /**
367 * Implementation of parser_t.parse_payload.
368 */
369 static status_t parse_payload(private_parser_t *this,
370 payload_type_t payload_type, payload_t **payload)
371 {
372 payload_t *pld;
373 void *output;
374 size_t rule_count;
375 int payload_length = 0, spi_size = 0, attribute_length = 0;
376 u_int16_t ts_type = 0;
377 bool attribute_format = FALSE;
378 int rule_number;
379 encoding_rule_t *rule;
380
381 /* create instance of the payload to parse */
382 pld = payload_create(payload_type);
383
384 DBG2(DBG_ENC, "parsing %N payload, %d bytes left",
385 payload_type_names, payload_type, this->input_roof - this->byte_pos);
386
387 DBG3(DBG_ENC, "parsing payload from %b",
388 this->byte_pos, this->input_roof - this->byte_pos);
389
390 if (pld->get_type(pld) == UNKNOWN_PAYLOAD)
391 {
392 DBG1(DBG_ENC, " payload type %d is unknown, handling as %N",
393 payload_type, payload_type_names, UNKNOWN_PAYLOAD);
394 }
395
396 /* base pointer for output, avoids casting in every rule */
397 output = pld;
398
399 /* parse the payload with its own rulse */
400 pld->get_encoding_rules(pld, &this->rules, &rule_count);
401 for (rule_number = 0; rule_number < rule_count; rule_number++)
402 {
403 rule = &(this->rules[rule_number]);
404 DBG2(DBG_ENC, " parsing rule %d %N",
405 rule_number, encoding_type_names, rule->type);
406 switch (rule->type)
407 {
408 case U_INT_4:
409 {
410 if (!parse_uint4(this, rule_number, output + rule->offset))
411 {
412 pld->destroy(pld);
413 return PARSE_ERROR;
414 }
415 break;
416 }
417 case U_INT_8:
418 {
419 if (!parse_uint8(this, rule_number, output + rule->offset))
420 {
421 pld->destroy(pld);
422 return PARSE_ERROR;
423 }
424 break;
425 }
426 case U_INT_16:
427 {
428 if (!parse_uint16(this, rule_number, output + rule->offset))
429 {
430 pld->destroy(pld);
431 return PARSE_ERROR;
432 }
433 break;
434 }
435 case U_INT_32:
436 {
437 if (!parse_uint32(this, rule_number, output + rule->offset))
438 {
439 pld->destroy(pld);
440 return PARSE_ERROR;
441 }
442 break;
443 }
444 case IKE_SPI:
445 {
446 if (!parse_bytes(this, rule_number, output + rule->offset, 8))
447 {
448 pld->destroy(pld);
449 return PARSE_ERROR;
450 }
451 break;
452 }
453 case RESERVED_BIT:
454 {
455 if (!parse_bit(this, rule_number, NULL))
456 {
457 pld->destroy(pld);
458 return PARSE_ERROR;
459 }
460 break;
461 }
462 case RESERVED_BYTE:
463 {
464 if (!parse_uint8(this, rule_number, NULL))
465 {
466 pld->destroy(pld);
467 return PARSE_ERROR;
468 }
469 break;
470 }
471 case FLAG:
472 {
473 if (!parse_bit(this, rule_number, output + rule->offset))
474 {
475 pld->destroy(pld);
476 return PARSE_ERROR;
477 }
478 break;
479 }
480 case PAYLOAD_LENGTH:
481 {
482 if (!parse_uint16(this, rule_number, output + rule->offset))
483 {
484 pld->destroy(pld);
485 return PARSE_ERROR;
486 }
487 /* parsed u_int16 should be aligned */
488 payload_length = *(u_int16_t*)(output + rule->offset);
489 if (payload_length < UNKNOWN_PAYLOAD_HEADER_LENGTH)
490 {
491 pld->destroy(pld);
492 return PARSE_ERROR;
493 }
494 break;
495 }
496 case HEADER_LENGTH:
497 {
498 if (!parse_uint32(this, rule_number, output + rule->offset))
499 {
500 pld->destroy(pld);
501 return PARSE_ERROR;
502 }
503 break;
504 }
505 case SPI_SIZE:
506 {
507 if (!parse_uint8(this, rule_number, output + rule->offset))
508 {
509 pld->destroy(pld);
510 return PARSE_ERROR;
511 }
512 spi_size = *(u_int8_t*)(output + rule->offset);
513 break;
514 }
515 case SPI:
516 {
517 if (!parse_chunk(this, rule_number, output + rule->offset,
518 spi_size))
519 {
520 pld->destroy(pld);
521 return PARSE_ERROR;
522 }
523 break;
524 }
525 case PROPOSALS:
526 {
527 if (payload_length < SA_PAYLOAD_HEADER_LENGTH ||
528 !parse_list(this, rule_number, output + rule->offset,
529 PROPOSAL_SUBSTRUCTURE,
530 payload_length - SA_PAYLOAD_HEADER_LENGTH))
531 {
532 pld->destroy(pld);
533 return PARSE_ERROR;
534 }
535 break;
536 }
537 case TRANSFORMS:
538 {
539 if (payload_length <
540 spi_size + PROPOSAL_SUBSTRUCTURE_HEADER_LENGTH ||
541 !parse_list(this, rule_number, output + rule->offset,
542 TRANSFORM_SUBSTRUCTURE, payload_length - spi_size -
543 PROPOSAL_SUBSTRUCTURE_HEADER_LENGTH))
544 {
545 pld->destroy(pld);
546 return PARSE_ERROR;
547 }
548 break;
549 }
550 case TRANSFORM_ATTRIBUTES:
551 {
552 if (payload_length < TRANSFORM_SUBSTRUCTURE_HEADER_LENGTH ||
553 !parse_list(this, rule_number, output + rule->offset,
554 TRANSFORM_ATTRIBUTE,
555 payload_length - TRANSFORM_SUBSTRUCTURE_HEADER_LENGTH))
556 {
557 pld->destroy(pld);
558 return PARSE_ERROR;
559 }
560 break;
561 }
562 case CONFIGURATION_ATTRIBUTES:
563 {
564 if (payload_length < CP_PAYLOAD_HEADER_LENGTH ||
565 !parse_list(this, rule_number, output + rule->offset,
566 CONFIGURATION_ATTRIBUTE,
567 payload_length - CP_PAYLOAD_HEADER_LENGTH))
568 {
569 pld->destroy(pld);
570 return PARSE_ERROR;
571 }
572 break;
573 }
574 case ATTRIBUTE_FORMAT:
575 {
576 if (!parse_bit(this, rule_number, output + rule->offset))
577 {
578 pld->destroy(pld);
579 return PARSE_ERROR;
580 }
581 attribute_format = *(bool*)(output + rule->offset);
582 break;
583 }
584 case ATTRIBUTE_TYPE:
585 {
586 if (!parse_uint15(this, rule_number, output + rule->offset))
587 {
588 pld->destroy(pld);
589 return PARSE_ERROR;
590 }
591 break;
592 }
593 case CONFIGURATION_ATTRIBUTE_LENGTH:
594 {
595 if (!parse_uint16(this, rule_number, output + rule->offset))
596 {
597 pld->destroy(pld);
598 return PARSE_ERROR;
599 }
600 attribute_length = *(u_int16_t*)(output + rule->offset);
601 break;
602 }
603 case ATTRIBUTE_LENGTH_OR_VALUE:
604 {
605 if (!parse_uint16(this, rule_number, output + rule->offset))
606 {
607 pld->destroy(pld);
608 return PARSE_ERROR;
609 }
610 attribute_length = *(u_int16_t*)(output + rule->offset);
611 break;
612 }
613 case ATTRIBUTE_VALUE:
614 {
615 if (attribute_format == FALSE &&
616 !parse_chunk(this, rule_number, output + rule->offset,
617 attribute_length))
618 {
619 pld->destroy(pld);
620 return PARSE_ERROR;
621 }
622 break;
623 }
624 case NONCE_DATA:
625 {
626 if (payload_length < NONCE_PAYLOAD_HEADER_LENGTH ||
627 !parse_chunk(this, rule_number, output + rule->offset,
628 payload_length - NONCE_PAYLOAD_HEADER_LENGTH))
629 {
630 pld->destroy(pld);
631 return PARSE_ERROR;
632 }
633 break;
634 }
635 case ID_DATA:
636 {
637 if (payload_length < ID_PAYLOAD_HEADER_LENGTH ||
638 !parse_chunk(this, rule_number, output + rule->offset,
639 payload_length - ID_PAYLOAD_HEADER_LENGTH))
640 {
641 pld->destroy(pld);
642 return PARSE_ERROR;
643 }
644 break;
645 }
646 case AUTH_DATA:
647 {
648 if (payload_length < AUTH_PAYLOAD_HEADER_LENGTH ||
649 !parse_chunk(this, rule_number, output + rule->offset,
650 payload_length - AUTH_PAYLOAD_HEADER_LENGTH))
651 {
652 pld->destroy(pld);
653 return PARSE_ERROR;
654 }
655 break;
656 }
657 case CERT_DATA:
658 {
659 if (payload_length < CERT_PAYLOAD_HEADER_LENGTH ||
660 !parse_chunk(this, rule_number, output + rule->offset,
661 payload_length - CERT_PAYLOAD_HEADER_LENGTH))
662 {
663 pld->destroy(pld);
664 return PARSE_ERROR;
665 }
666 break;
667 }
668 case CERTREQ_DATA:
669 {
670 if (payload_length < CERTREQ_PAYLOAD_HEADER_LENGTH ||
671 !parse_chunk(this, rule_number, output + rule->offset,
672 payload_length - CERTREQ_PAYLOAD_HEADER_LENGTH))
673 {
674 pld->destroy(pld);
675 return PARSE_ERROR;
676 }
677 break;
678 }
679 case EAP_DATA:
680 {
681 if (payload_length < EAP_PAYLOAD_HEADER_LENGTH ||
682 !parse_chunk(this, rule_number, output + rule->offset,
683 payload_length - EAP_PAYLOAD_HEADER_LENGTH))
684 {
685 pld->destroy(pld);
686 return PARSE_ERROR;
687 }
688 break;
689 }
690 case SPIS:
691 {
692 if (payload_length < DELETE_PAYLOAD_HEADER_LENGTH ||
693 !parse_chunk(this, rule_number, output + rule->offset,
694 payload_length - DELETE_PAYLOAD_HEADER_LENGTH))
695 {
696 pld->destroy(pld);
697 return PARSE_ERROR;
698 }
699 break;
700 }
701 case VID_DATA:
702 {
703 if (payload_length < VENDOR_ID_PAYLOAD_HEADER_LENGTH ||
704 !parse_chunk(this, rule_number, output + rule->offset,
705 payload_length - VENDOR_ID_PAYLOAD_HEADER_LENGTH))
706 {
707 pld->destroy(pld);
708 return PARSE_ERROR;
709 }
710 break;
711 }
712 case CONFIGURATION_ATTRIBUTE_VALUE:
713 {
714 if (!parse_chunk(this, rule_number, output + rule->offset,
715 attribute_length))
716 {
717 pld->destroy(pld);
718 return PARSE_ERROR;
719 }
720 break;
721 }
722 case KEY_EXCHANGE_DATA:
723 {
724 if (payload_length < KE_PAYLOAD_HEADER_LENGTH ||
725 !parse_chunk(this, rule_number, output + rule->offset,
726 payload_length - KE_PAYLOAD_HEADER_LENGTH))
727 {
728 pld->destroy(pld);
729 return PARSE_ERROR;
730 }
731 break;
732 }
733 case NOTIFICATION_DATA:
734 {
735 if (payload_length < NOTIFY_PAYLOAD_HEADER_LENGTH + spi_size ||
736 !parse_chunk(this, rule_number, output + rule->offset,
737 payload_length - NOTIFY_PAYLOAD_HEADER_LENGTH - spi_size))
738 {
739 pld->destroy(pld);
740 return PARSE_ERROR;
741 }
742 break;
743 }
744 case ENCRYPTED_DATA:
745 {
746 if (payload_length < ENCRYPTION_PAYLOAD_HEADER_LENGTH ||
747 !parse_chunk(this, rule_number, output + rule->offset,
748 payload_length - ENCRYPTION_PAYLOAD_HEADER_LENGTH))
749 {
750 pld->destroy(pld);
751 return PARSE_ERROR;
752 }
753 break;
754 }
755 case TS_TYPE:
756 {
757 if (!parse_uint8(this, rule_number, output + rule->offset))
758 {
759 pld->destroy(pld);
760 return PARSE_ERROR;
761 }
762 ts_type = *(u_int8_t*)(output + rule->offset);
763 break;
764 }
765 case ADDRESS:
766 {
767 int address_length = (ts_type == TS_IPV4_ADDR_RANGE) ? 4 : 16;
768
769 if (!parse_chunk(this, rule_number, output + rule->offset,
770 address_length))
771 {
772 pld->destroy(pld);
773 return PARSE_ERROR;
774 }
775 break;
776 }
777 case TRAFFIC_SELECTORS:
778 {
779 if (payload_length < TS_PAYLOAD_HEADER_LENGTH ||
780 !parse_list(this, rule_number, output + rule->offset,
781 TRAFFIC_SELECTOR_SUBSTRUCTURE,
782 payload_length - TS_PAYLOAD_HEADER_LENGTH))
783 {
784 pld->destroy(pld);
785 return PARSE_ERROR;
786 }
787 break;
788 }
789 case UNKNOWN_DATA:
790 {
791 if (payload_length < UNKNOWN_PAYLOAD_HEADER_LENGTH ||
792 !parse_chunk(this, rule_number, output + rule->offset,
793 payload_length - UNKNOWN_PAYLOAD_HEADER_LENGTH))
794 {
795 pld->destroy(pld);
796 return PARSE_ERROR;
797 }
798 break;
799 }
800 default:
801 {
802 DBG1(DBG_ENC, " no rule to parse rule %d %N",
803 rule_number, encoding_type_names, rule->type);
804 pld->destroy(pld);
805 return PARSE_ERROR;
806 }
807 }
808 /* process next rulue */
809 rule++;
810 }
811
812 *payload = pld;
813 DBG2(DBG_ENC, "parsing %N payload finished",
814 payload_type_names, payload_type);
815 return SUCCESS;
816 }
817
818 /**
819 * Implementation of parser_t.get_remaining_byte_count.
820 */
821 static int get_remaining_byte_count (private_parser_t *this)
822 {
823 return this->input_roof - this->byte_pos;
824 }
825
826 /**
827 * Implementation of parser_t.reset_context.
828 */
829 static void reset_context (private_parser_t *this)
830 {
831 this->byte_pos = this->input;
832 this->bit_pos = 0;
833 }
834
835 /**
836 * Implementation of parser_t.destroy.
837 */
838 static void destroy(private_parser_t *this)
839 {
840 free(this);
841 }
842
843 /*
844 * Described in header.
845 */
846 parser_t *parser_create(chunk_t data)
847 {
848 private_parser_t *this = malloc_thing(private_parser_t);
849
850 this->public.parse_payload = (status_t(*)(parser_t*,payload_type_t,payload_t**))parse_payload;
851 this->public.reset_context = (void(*)(parser_t*)) reset_context;
852 this->public.get_remaining_byte_count = (int (*) (parser_t *))get_remaining_byte_count;
853 this->public.destroy = (void(*)(parser_t*)) destroy;
854
855 this->input = data.ptr;
856 this->byte_pos = data.ptr;
857 this->bit_pos = 0;
858 this->input_roof = data.ptr + data.len;
859
860 return &this->public;
861 }
862