Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 1 | /* Copyright (c) 2014, Google Inc. |
| 2 | * |
| 3 | * Permission to use, copy, modify, and/or distribute this software for any |
| 4 | * purpose with or without fee is hereby granted, provided that the above |
| 5 | * copyright notice and this permission notice appear in all copies. |
| 6 | * |
| 7 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
| 8 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
| 9 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY |
| 10 | * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
| 11 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION |
| 12 | * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN |
| 13 | * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ |
| 14 | |
| 15 | #ifndef OPENSSL_HEADER_BYTESTRING_H |
| 16 | #define OPENSSL_HEADER_BYTESTRING_H |
| 17 | |
| 18 | #include <openssl/base.h> |
| 19 | |
| 20 | #if defined(__cplusplus) |
| 21 | extern "C" { |
| 22 | #endif |
| 23 | |
| 24 | |
| 25 | /* Bytestrings are used for parsing and building TLS and ASN.1 messages. |
| 26 | * |
| 27 | * A "CBS" (CRYPTO ByteString) represents a string of bytes in memory and |
| 28 | * provides utility functions for safely parsing length-prefixed structures |
| 29 | * like TLS and ASN.1 from it. |
| 30 | * |
| 31 | * A "CBB" (CRYPTO ByteBuilder) is a memory buffer that grows as needed and |
| 32 | * provides utility functions for building length-prefixed messages. */ |
| 33 | |
| 34 | |
| 35 | /* CRYPTO ByteString */ |
| 36 | |
| 37 | struct cbs_st { |
| 38 | const uint8_t *data; |
| 39 | size_t len; |
| 40 | }; |
| 41 | |
| 42 | /* CBS_init sets |cbs| to point to |data|. It does not take ownership of |
| 43 | * |data|. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 44 | OPENSSL_EXPORT void CBS_init(CBS *cbs, const uint8_t *data, size_t len); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 45 | |
| 46 | /* CBS_skip advances |cbs| by |len| bytes. It returns one on success and zero |
| 47 | * otherwise. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 48 | OPENSSL_EXPORT int CBS_skip(CBS *cbs, size_t len); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 49 | |
| 50 | /* CBS_data returns a pointer to the contains of |cbs|. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 51 | OPENSSL_EXPORT const uint8_t *CBS_data(const CBS *cbs); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 52 | |
| 53 | /* CBS_len returns the number of bytes remaining in |cbs|. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 54 | OPENSSL_EXPORT size_t CBS_len(const CBS *cbs); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 55 | |
David Benjamin | 0397309 | 2014-06-24 23:27:17 -0400 | [diff] [blame] | 56 | /* CBS_stow copies the current contents of |cbs| into |*out_ptr| and |
| 57 | * |*out_len|. If |*out_ptr| is not NULL, the contents are freed with |
| 58 | * OPENSSL_free. It returns one on success and zero on allocation failure. On |
| 59 | * success, |*out_ptr| should be freed with OPENSSL_free. If |cbs| is empty, |
| 60 | * |*out_ptr| will be NULL. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 61 | OPENSSL_EXPORT int CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len); |
David Benjamin | 0397309 | 2014-06-24 23:27:17 -0400 | [diff] [blame] | 62 | |
David Benjamin | ed43958 | 2014-07-14 19:13:02 -0400 | [diff] [blame] | 63 | /* CBS_strdup copies the current contents of |cbs| into |*out_ptr| as a |
| 64 | * NUL-terminated C string. If |*out_ptr| is not NULL, the contents are freed |
| 65 | * with OPENSSL_free. It returns one on success and zero on allocation |
| 66 | * failure. On success, |*out_ptr| should be freed with OPENSSL_free. |
| 67 | * |
| 68 | * NOTE: If |cbs| contains NUL bytes, the string will be truncated. Call |
| 69 | * |CBS_contains_zero_byte(cbs)| to check for NUL bytes. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 70 | OPENSSL_EXPORT int CBS_strdup(const CBS *cbs, char **out_ptr); |
David Benjamin | ed43958 | 2014-07-14 19:13:02 -0400 | [diff] [blame] | 71 | |
| 72 | /* CBS_contains_zero_byte returns one if the current contents of |cbs| contains |
| 73 | * a NUL byte and zero otherwise. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 74 | OPENSSL_EXPORT int CBS_contains_zero_byte(const CBS *cbs); |
David Benjamin | ed43958 | 2014-07-14 19:13:02 -0400 | [diff] [blame] | 75 | |
David Benjamin | 22f9bcc | 2014-07-13 12:29:21 -0400 | [diff] [blame] | 76 | /* CBS_mem_equal compares the current contents of |cbs| with the |len| bytes |
| 77 | * starting at |data|. If they're equal, it returns one, otherwise zero. If the |
| 78 | * lengths match, it uses a constant-time comparison. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 79 | OPENSSL_EXPORT int CBS_mem_equal(const CBS *cbs, const uint8_t *data, |
| 80 | size_t len); |
David Benjamin | 22f9bcc | 2014-07-13 12:29:21 -0400 | [diff] [blame] | 81 | |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 82 | /* CBS_get_u8 sets |*out| to the next uint8_t from |cbs| and advances |cbs|. It |
| 83 | * returns one on success and zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 84 | OPENSSL_EXPORT int CBS_get_u8(CBS *cbs, uint8_t *out); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 85 | |
| 86 | /* CBS_get_u16 sets |*out| to the next, big-endian uint16_t from |cbs| and |
| 87 | * advances |cbs|. It returns one on success and zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 88 | OPENSSL_EXPORT int CBS_get_u16(CBS *cbs, uint16_t *out); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 89 | |
| 90 | /* CBS_get_u24 sets |*out| to the next, big-endian 24-bit value from |cbs| and |
| 91 | * advances |cbs|. It returns one on success and zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 92 | OPENSSL_EXPORT int CBS_get_u24(CBS *cbs, uint32_t *out); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 93 | |
| 94 | /* CBS_get_u32 sets |*out| to the next, big-endian uint32_t value from |cbs| |
| 95 | * and advances |cbs|. It returns one on success and zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 96 | OPENSSL_EXPORT int CBS_get_u32(CBS *cbs, uint32_t *out); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 97 | |
| 98 | /* CBS_get_bytes sets |*out| to the next |len| bytes from |cbs| and advances |
| 99 | * |cbs|. It returns one on success and zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 100 | OPENSSL_EXPORT int CBS_get_bytes(CBS *cbs, CBS *out, size_t len); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 101 | |
| 102 | /* CBS_get_u8_length_prefixed sets |*out| to the contents of an 8-bit, |
| 103 | * length-prefixed value from |cbs| and advances |cbs| over it. It returns one |
| 104 | * on success and zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 105 | OPENSSL_EXPORT int CBS_get_u8_length_prefixed(CBS *cbs, CBS *out); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 106 | |
| 107 | /* CBS_get_u16_length_prefixed sets |*out| to the contents of a 16-bit, |
| 108 | * big-endian, length-prefixed value from |cbs| and advances |cbs| over it. It |
| 109 | * returns one on success and zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 110 | OPENSSL_EXPORT int CBS_get_u16_length_prefixed(CBS *cbs, CBS *out); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 111 | |
| 112 | /* CBS_get_u24_length_prefixed sets |*out| to the contents of a 24-bit, |
| 113 | * big-endian, length-prefixed value from |cbs| and advances |cbs| over it. It |
| 114 | * returns one on success and zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 115 | OPENSSL_EXPORT int CBS_get_u24_length_prefixed(CBS *cbs, CBS *out); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 116 | |
| 117 | |
| 118 | /* Parsing ASN.1 */ |
| 119 | |
| 120 | #define CBS_ASN1_BOOLEAN 0x1 |
| 121 | #define CBS_ASN1_INTEGER 0x2 |
| 122 | #define CBS_ASN1_BITSTRING 0x3 |
| 123 | #define CBS_ASN1_OCTETSTRING 0x4 |
| 124 | #define CBS_ASN1_OBJECT 0x6 |
David Benjamin | ed6eb66 | 2014-08-28 16:28:18 -0400 | [diff] [blame] | 125 | #define CBS_ASN1_ENUMERATED 0xa |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 126 | #define CBS_ASN1_SEQUENCE (0x10 | CBS_ASN1_CONSTRUCTED) |
| 127 | #define CBS_ASN1_SET (0x11 | CBS_ASN1_CONSTRUCTED) |
| 128 | |
| 129 | #define CBS_ASN1_CONSTRUCTED 0x20 |
| 130 | #define CBS_ASN1_CONTEXT_SPECIFIC 0x80 |
| 131 | |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 132 | /* CBS_get_asn1 sets |*out| to the contents of DER-encoded, ASN.1 element (not |
| 133 | * including tag and length bytes) and advances |cbs| over it. The ASN.1 |
| 134 | * element must match |tag_value|. It returns one on success and zero |
| 135 | * on error. |
| 136 | * |
| 137 | * Tag numbers greater than 31 are not supported. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 138 | OPENSSL_EXPORT int CBS_get_asn1(CBS *cbs, CBS *out, unsigned tag_value); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 139 | |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 140 | /* CBS_get_asn1_element acts like |CBS_get_asn1| but |out| will include the |
| 141 | * ASN.1 header bytes too. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 142 | OPENSSL_EXPORT int CBS_get_asn1_element(CBS *cbs, CBS *out, unsigned tag_value); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 143 | |
David Benjamin | 9b04d65 | 2014-08-27 20:19:50 -0400 | [diff] [blame] | 144 | /* CBS_get_any_asn1_element sets |*out| to contain the next ASN.1 element from |
| 145 | * |*cbs| (including header bytes) and advances |*cbs|. It sets |*out_tag| to |
| 146 | * the tag number and |*out_header_len| to the length of the ASN.1 header. If |
| 147 | * the element has indefinite length then |*out| will only contain the |
| 148 | * header. Each of |out|, |out_tag|, and |out_header_len| may be NULL to ignore |
| 149 | * the value. |
| 150 | * |
| 151 | * Tag numbers greater than 31 are not supported. */ |
| 152 | OPENSSL_EXPORT int CBS_get_any_asn1_element(CBS *cbs, CBS *out, |
| 153 | unsigned *out_tag, |
| 154 | size_t *out_header_len); |
| 155 | |
Adam Langley | 9c01e00 | 2014-08-21 10:54:06 -0700 | [diff] [blame] | 156 | /* CBS_get_asn1_uint64 gets an ASN.1 INTEGER from |cbs| using |CBS_get_asn1| |
| 157 | * and sets |*out| to its value. It returns one on success and zero on error, |
| 158 | * where error includes the integer being negative, or too large to represent |
| 159 | * in 64 bits. */ |
| 160 | OPENSSL_EXPORT int CBS_get_asn1_uint64(CBS *cbs, uint64_t *out); |
| 161 | |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 162 | |
| 163 | /* CRYPTO ByteBuilder. |
| 164 | * |
| 165 | * |CBB| objects allow one to build length-prefixed serialisations. A |CBB| |
| 166 | * object is associated with a buffer and new buffers are created with |
| 167 | * |CBB_init|. Several |CBB| objects can point at the same buffer when a |
| 168 | * length-prefix is pending, however only a single |CBB| can be 'current' at |
| 169 | * any one time. For example, if one calls |CBB_add_u8_length_prefixed| then |
| 170 | * the new |CBB| points at the same buffer as the original. But if the original |
| 171 | * |CBB| is used then the length prefix is written out and the new |CBB| must |
| 172 | * not be used again. |
| 173 | * |
| 174 | * If one needs to force a length prefix to be written out because a |CBB| is |
| 175 | * going out of scope, use |CBB_flush|. */ |
| 176 | |
| 177 | struct cbb_buffer_st { |
| 178 | uint8_t *buf; |
| 179 | size_t len; /* The number of valid bytes. */ |
| 180 | size_t cap; /* The size of buf. */ |
| 181 | char can_resize; /* One iff |buf| is owned by this object. If not then |buf| |
| 182 | cannot be resized. */ |
| 183 | }; |
| 184 | |
| 185 | struct cbb_st { |
| 186 | struct cbb_buffer_st *base; |
| 187 | /* offset is the offset from the start of |base->buf| to the position of any |
| 188 | * pending length-prefix. */ |
| 189 | size_t offset; |
| 190 | /* child points to a child CBB if a length-prefix is pending. */ |
| 191 | struct cbb_st *child; |
| 192 | /* pending_len_len contains the number of bytes in a pending length-prefix, |
| 193 | * or zero if no length-prefix is pending. */ |
| 194 | uint8_t pending_len_len; |
| 195 | char pending_is_asn1; |
| 196 | /* is_top_level is true iff this is a top-level |CBB| (as opposed to a child |
| 197 | * |CBB|). Top-level objects are valid arguments for |CBB_finish|. */ |
| 198 | char is_top_level; |
| 199 | }; |
| 200 | |
| 201 | /* CBB_init initialises |cbb| with |initial_capacity|. Since a |CBB| grows as |
| 202 | * needed, the |initial_capacity| is just a hint. It returns one on success or |
| 203 | * zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 204 | OPENSSL_EXPORT int CBB_init(CBB *cbb, size_t initial_capacity); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 205 | |
| 206 | /* CBB_init_fixed initialises |cbb| to write to |len| bytes at |buf|. Since |
| 207 | * |buf| cannot grow, trying to write more than |len| bytes will cause CBB |
| 208 | * functions to fail. It returns one on success or zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 209 | OPENSSL_EXPORT int CBB_init_fixed(CBB *cbb, uint8_t *buf, size_t len); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 210 | |
| 211 | /* CBB_cleanup frees all resources owned by |cbb| and other |CBB| objects |
| 212 | * writing to the same buffer. This should be used in an error case where a |
| 213 | * serialisation is abandoned. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 214 | OPENSSL_EXPORT void CBB_cleanup(CBB *cbb); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 215 | |
| 216 | /* CBB_finish completes any pending length prefix and sets |*out_data| to a |
| 217 | * malloced buffer and |*out_len| to the length of that buffer. The caller |
| 218 | * takes ownership of the buffer and, unless the buffer was fixed with |
| 219 | * |CBB_init_fixed|, must call |OPENSSL_free| when done. |
| 220 | * |
| 221 | * It can only be called on a "top level" |CBB|, i.e. one initialised with |
| 222 | * |CBB_init| or |CBB_init_fixed|. It returns one on success and zero on |
| 223 | * error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 224 | OPENSSL_EXPORT int CBB_finish(CBB *cbb, uint8_t **out_data, size_t *out_len); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 225 | |
| 226 | /* CBB_flush causes any pending length prefixes to be written out and any child |
| 227 | * |CBB| objects of |cbb| to be invalidated. It returns one on success or zero |
| 228 | * on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 229 | OPENSSL_EXPORT int CBB_flush(CBB *cbb); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 230 | |
| 231 | /* CBB_add_u8_length_prefixed sets |*out_contents| to a new child of |cbb|. The |
| 232 | * data written to |*out_contents| will be prefixed in |cbb| with an 8-bit |
| 233 | * length. It returns one on success or zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 234 | OPENSSL_EXPORT int CBB_add_u8_length_prefixed(CBB *cbb, CBB *out_contents); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 235 | |
| 236 | /* CBB_add_u16_length_prefixed sets |*out_contents| to a new child of |cbb|. |
| 237 | * The data written to |*out_contents| will be prefixed in |cbb| with a 16-bit, |
| 238 | * big-endian length. It returns one on success or zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 239 | OPENSSL_EXPORT int CBB_add_u16_length_prefixed(CBB *cbb, CBB *out_contents); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 240 | |
| 241 | /* CBB_add_u24_length_prefixed sets |*out_contents| to a new child of |cbb|. |
| 242 | * The data written to |*out_contents| will be prefixed in |cbb| with a 24-bit, |
| 243 | * big-endian length. It returns one on success or zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 244 | OPENSSL_EXPORT int CBB_add_u24_length_prefixed(CBB *cbb, CBB *out_contents); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 245 | |
| 246 | /* CBB_add_asn sets |*out_contents| to a |CBB| into which the contents of an |
| 247 | * ASN.1 object can be written. The |tag| argument will be used as the tag for |
| 248 | * the object. It returns one on success or zero on error. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 249 | OPENSSL_EXPORT int CBB_add_asn1(CBB *cbb, CBB *out_contents, uint8_t tag); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 250 | |
| 251 | /* CBB_add_bytes appends |len| bytes from |data| to |cbb|. It returns one on |
| 252 | * success and zero otherwise. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 253 | OPENSSL_EXPORT int CBB_add_bytes(CBB *cbb, const uint8_t *data, size_t len); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 254 | |
Adam Langley | eeb9f49 | 2014-08-06 16:29:56 -0700 | [diff] [blame] | 255 | /* CBB_add_space appends |len| bytes to |cbb| and sets |*out_data| to point to |
| 256 | * the beginning of that space. The caller must then write |len| bytes of |
| 257 | * actual contents to |*out_data|. It returns one on success and zero |
| 258 | * otherwise. */ |
| 259 | OPENSSL_EXPORT int CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len); |
| 260 | |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 261 | /* CBB_add_u8 appends an 8-bit number from |value| to |cbb|. It returns one on |
| 262 | * success and zero otherwise. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 263 | OPENSSL_EXPORT int CBB_add_u8(CBB *cbb, uint8_t value); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 264 | |
| 265 | /* CBB_add_u8 appends a 16-bit, big-endian number from |value| to |cbb|. It |
| 266 | * returns one on success and zero otherwise. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 267 | OPENSSL_EXPORT int CBB_add_u16(CBB *cbb, uint16_t value); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 268 | |
| 269 | /* CBB_add_u24 appends a 24-bit, big-endian number from |value| to |cbb|. It |
| 270 | * returns one on success and zero otherwise. */ |
Adam Langley | eb7d2ed | 2014-07-30 16:02:14 -0700 | [diff] [blame] | 271 | OPENSSL_EXPORT int CBB_add_u24(CBB *cbb, uint32_t value); |
Adam Langley | 95c29f3 | 2014-06-20 12:00:00 -0700 | [diff] [blame] | 272 | |
| 273 | |
| 274 | #if defined(__cplusplus) |
| 275 | } /* extern C */ |
| 276 | #endif |
| 277 | |
| 278 | #endif /* OPENSSL_HEADER_BYTESTRING_H */ |