Jeff Thompson | 47eecfc | 2013-07-07 22:56:46 -0700 | [diff] [blame] | 1 | /** |
| 2 | * @author: Jeff Thompson |
| 3 | * See COPYING for copyright and distribution information. |
Jeff Thompson | 76317aa | 2013-06-25 19:11:48 -0700 | [diff] [blame] | 4 | */ |
| 5 | |
| 6 | #ifndef NDN_BINARYXMLDECODER_H |
| 7 | #define NDN_BINARYXMLDECODER_H |
| 8 | |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 9 | #include "../errors.h" |
| 10 | |
Jeff Thompson | 76317aa | 2013-06-25 19:11:48 -0700 | [diff] [blame] | 11 | #ifdef __cplusplus |
| 12 | extern "C" { |
| 13 | #endif |
| 14 | |
| 15 | struct ndn_BinaryXMLDecoder { |
Jeff Thompson | d6f1328 | 2013-06-27 17:31:50 -0700 | [diff] [blame] | 16 | unsigned char *input; |
Jeff Thompson | f731669 | 2013-06-26 21:31:42 -0700 | [diff] [blame] | 17 | unsigned int inputLength; |
Jeff Thompson | 76317aa | 2013-06-25 19:11:48 -0700 | [diff] [blame] | 18 | unsigned int offset; |
| 19 | }; |
| 20 | |
Jeff Thompson | d6f1328 | 2013-06-27 17:31:50 -0700 | [diff] [blame] | 21 | static inline void ndn_BinaryXMLDecoder_init(struct ndn_BinaryXMLDecoder *self, unsigned char *input, unsigned int inputLength) |
Jeff Thompson | 6c9b651 | 2013-06-27 15:59:47 -0700 | [diff] [blame] | 22 | { |
Jeff Thompson | 76317aa | 2013-06-25 19:11:48 -0700 | [diff] [blame] | 23 | self->input = input; |
Jeff Thompson | f731669 | 2013-06-26 21:31:42 -0700 | [diff] [blame] | 24 | self->inputLength = inputLength; |
Jeff Thompson | 76317aa | 2013-06-25 19:11:48 -0700 | [diff] [blame] | 25 | self->offset = 0; |
| 26 | } |
| 27 | |
Jeff Thompson | 179d050 | 2013-06-28 11:36:00 -0700 | [diff] [blame] | 28 | /** |
| 29 | * Decode the header's type and value from self's input starting at offset. Update offset. |
Jeff Thompson | 179d050 | 2013-06-28 11:36:00 -0700 | [diff] [blame] | 30 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
| 31 | * @param type output for the header type |
| 32 | * @param value output for the header value |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 33 | * @return 0 for success, else an error code for read past the end of the input or if the initial byte is zero |
Jeff Thompson | 179d050 | 2013-06-28 11:36:00 -0700 | [diff] [blame] | 34 | */ |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 35 | ndn_Error ndn_BinaryXMLDecoder_decodeTypeAndValue(struct ndn_BinaryXMLDecoder *self, unsigned int *type, unsigned int *value); |
Jeff Thompson | 76317aa | 2013-06-25 19:11:48 -0700 | [diff] [blame] | 36 | |
Jeff Thompson | f731669 | 2013-06-26 21:31:42 -0700 | [diff] [blame] | 37 | /** |
Jeff Thompson | 74ab081 | 2013-06-28 12:25:04 -0700 | [diff] [blame] | 38 | * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag. |
| 39 | * Update offset. |
Jeff Thompson | 179d050 | 2013-06-28 11:36:00 -0700 | [diff] [blame] | 40 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
Jeff Thompson | 74ab081 | 2013-06-28 12:25:04 -0700 | [diff] [blame] | 41 | * @param expectedTag the expected value for DTAG |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 42 | * @return 0 for success, else an error code, including an error if not the expected tag |
Jeff Thompson | 179d050 | 2013-06-28 11:36:00 -0700 | [diff] [blame] | 43 | */ |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 44 | ndn_Error ndn_BinaryXMLDecoder_readElementStartDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag); |
Jeff Thompson | 74ab081 | 2013-06-28 12:25:04 -0700 | [diff] [blame] | 45 | |
| 46 | /** |
| 47 | * Read one byte from self's input starting at offset, expecting it to be the element close. |
| 48 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 49 | * @return 0 for success, else an error code, including an error if not the element close |
Jeff Thompson | 74ab081 | 2013-06-28 12:25:04 -0700 | [diff] [blame] | 50 | */ |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 51 | ndn_Error ndn_BinaryXMLDecoder_readElementClose(struct ndn_BinaryXMLDecoder *self); |
Jeff Thompson | 74ab081 | 2013-06-28 12:25:04 -0700 | [diff] [blame] | 52 | |
| 53 | /** |
| 54 | * Decode the header from self's input starting at offset, and if it is a DTAG where the value is the expectedTag, |
| 55 | * then set gotExpectedTag to 1, else 0. Do not update offset, including if returning an error. |
| 56 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
| 57 | * @param expectedTag the expected value for DTAG |
| 58 | * @param gotExpectedTag output a 1 if got the expected tag, else 0 |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 59 | * @return 0 for success, else an error code for read past the end of the input |
Jeff Thompson | 74ab081 | 2013-06-28 12:25:04 -0700 | [diff] [blame] | 60 | */ |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 61 | ndn_Error ndn_BinaryXMLDecoder_peekDTag(struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *gotExpectedTag); |
Jeff Thompson | 179d050 | 2013-06-28 11:36:00 -0700 | [diff] [blame] | 62 | |
| 63 | /** |
Jeff Thompson | b4ee400 | 2013-06-28 13:41:43 -0700 | [diff] [blame] | 64 | * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag. |
| 65 | * Then read one item of any type (presumably BLOB, UDATA, TAG or ATTR) and return the item's value and length. |
| 66 | * However, if allowNull is 1, then the item may be absent. |
| 67 | * Finally, read the element close. Update offset. |
| 68 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
| 69 | * @param expectedTag the expected value for DTAG |
| 70 | * @param allowNull 1 if the binary item may be missing |
| 71 | * @param value output a pointer to the binary data inside self's input buffer. However, if allowNull is 1 and the |
| 72 | * binary data item is absent, then return 0. |
| 73 | * @param valueLen output the length of the binary data. However, if allowNull is 1 and the |
| 74 | * binary data item is absent, then return 0. |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 75 | * @return 0 for success, else an error code, including an error if not the expected tag, or if allowNull is 0 |
Jeff Thompson | b4ee400 | 2013-06-28 13:41:43 -0700 | [diff] [blame] | 76 | * and the binary data is absent |
| 77 | */ |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 78 | ndn_Error ndn_BinaryXMLDecoder_readBinaryDTagElement |
Jeff Thompson | b4ee400 | 2013-06-28 13:41:43 -0700 | [diff] [blame] | 79 | (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int allowNull, unsigned char **value, unsigned int *valueLen); |
| 80 | |
| 81 | /** |
Jeff Thompson | 167ca5a | 2013-07-07 20:45:43 -0700 | [diff] [blame] | 82 | * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag. |
| 83 | * Then read one item expecting it to be type UDATA, and return the item's value and length. |
| 84 | * Finally, read the element close. Update offset. |
| 85 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
| 86 | * @param expectedTag the expected value for DTAG |
| 87 | * @param value output a pointer to the binary data inside self's input buffer. |
| 88 | * @param valueLen output the length of the binary data. |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 89 | * @return 0 for success, else an error code, including an error if not the expected tag, or if the item is not UDATA. |
Jeff Thompson | 167ca5a | 2013-07-07 20:45:43 -0700 | [diff] [blame] | 90 | */ |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 91 | ndn_Error ndn_BinaryXMLDecoder_readUDataDTagElement |
Jeff Thompson | 167ca5a | 2013-07-07 20:45:43 -0700 | [diff] [blame] | 92 | (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned char **value, unsigned int *valueLen); |
| 93 | |
| 94 | /** |
| 95 | * Decode the header from self's input starting at offset, expecting the type to be DTAG and the value to be expectedTag. |
| 96 | * Then read one item expecting it to be type UDATA, parse it as an unsigned decimal integer and return the integer. |
| 97 | * Finally, read the element close. Update offset. |
| 98 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
| 99 | * @param expectedTag the expected value for DTAG |
| 100 | * @param value output the unsigned integer |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 101 | * @return 0 for success, else an error code, including an error if not the expected tag, or if the item is not UDATA, |
Jeff Thompson | 167ca5a | 2013-07-07 20:45:43 -0700 | [diff] [blame] | 102 | * or can't parse the integer |
| 103 | */ |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 104 | ndn_Error ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement |
Jeff Thompson | 167ca5a | 2013-07-07 20:45:43 -0700 | [diff] [blame] | 105 | (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, unsigned int *value); |
| 106 | |
| 107 | /** |
| 108 | * Peek at the next element, and if it has the expectedTag then call ndn_BinaryXMLDecoder_readUnsignedIntegerDTagElement. |
| 109 | * Otherwise, set value to -1. |
| 110 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
| 111 | * @param expectedTag the expected value for DTAG |
| 112 | * @param value output the unsigned integer cast to int, or -1 if the next element doesn't have expectedTag. |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 113 | * @return 0 for success, else an error code, including an error if the item is not UDATA, |
Jeff Thompson | 167ca5a | 2013-07-07 20:45:43 -0700 | [diff] [blame] | 114 | * or can't parse the integer |
| 115 | */ |
Jeff Thompson | 8b66600 | 2013-07-08 01:16:26 -0700 | [diff] [blame^] | 116 | ndn_Error ndn_BinaryXMLDecoder_readOptionalUnsignedIntegerDTagElement |
Jeff Thompson | 167ca5a | 2013-07-07 20:45:43 -0700 | [diff] [blame] | 117 | (struct ndn_BinaryXMLDecoder *self, unsigned int expectedTag, int *value); |
| 118 | |
| 119 | /** |
Jeff Thompson | 5abaaca | 2013-07-07 21:16:04 -0700 | [diff] [blame] | 120 | * Convert the big endian bytes to an unsigned int. Don't check for overflow. |
| 121 | * @param bytes pointer to the array of bytes |
| 122 | * @param bytesLength the length of bytes |
| 123 | * @return the result unsigned int |
| 124 | */ |
| 125 | unsigned int ndn_BinaryXMLDecoder_bigEndianToUnsignedInt(unsigned char *bytes, unsigned int bytesLength); |
| 126 | |
| 127 | /** |
Jeff Thompson | f731669 | 2013-06-26 21:31:42 -0700 | [diff] [blame] | 128 | * Set the offset into the input, used for the next read. |
| 129 | * @param self pointer to the ndn_BinaryXMLDecoder struct |
| 130 | * @param offset the new offset |
| 131 | */ |
Jeff Thompson | 6c9b651 | 2013-06-27 15:59:47 -0700 | [diff] [blame] | 132 | static inline void ndn_BinaryXMLDecoder_seek(struct ndn_BinaryXMLDecoder *self, unsigned int offset) |
| 133 | { |
Jeff Thompson | f731669 | 2013-06-26 21:31:42 -0700 | [diff] [blame] | 134 | self->offset = offset; |
| 135 | } |
| 136 | |
Jeff Thompson | 76317aa | 2013-06-25 19:11:48 -0700 | [diff] [blame] | 137 | #ifdef __cplusplus |
| 138 | } |
| 139 | #endif |
| 140 | |
| 141 | #endif |