/** As trn_cell_introduce_ack_parse(), but do not allocate the output * object. */ static ssize_t trn_cell_introduce_ack_parse_into(trn_cell_introduce_ack_t *obj, const uint8_t *input, const size_t len_in) { const uint8_t *ptr = input; size_t remaining = len_in; ssize_t result = 0; (void)result; /* Parse u16 status IN [0, 1, 2] */ CHECK_REMAINING(2, truncated); obj->status = trunnel_ntohs(trunnel_get_uint16(ptr)); remaining -= 2; ptr += 2; if (! (obj->status == 0 || obj->status == 1 || obj->status == 2)) goto fail; /* Parse struct trn_cell_extension extensions */ result = trn_cell_extension_parse(&obj->extensions, ptr, remaining); if (result < 0) goto relay_fail; trunnel_assert((size_t)result <= remaining); remaining -= result; ptr += result; trunnel_assert(ptr + remaining == input + len_in); return len_in - remaining; truncated: return -2; relay_fail: trunnel_assert(result < 0); return result; fail: result = -1; return result; }
/** As trn_cell_introduce1_parse(), but do not allocate the output * object. */ static ssize_t trn_cell_introduce1_parse_into(trn_cell_introduce1_t *obj, const uint8_t *input, const size_t len_in) { const uint8_t *ptr = input; size_t remaining = len_in; ssize_t result = 0; (void)result; /* Parse u8 legacy_key_id[TRUNNEL_SHA1_LEN] */ CHECK_REMAINING(TRUNNEL_SHA1_LEN, truncated); memcpy(obj->legacy_key_id, ptr, TRUNNEL_SHA1_LEN); remaining -= TRUNNEL_SHA1_LEN; ptr += TRUNNEL_SHA1_LEN; /* Parse u8 auth_key_type IN [0, 1, 2] */ CHECK_REMAINING(1, truncated); obj->auth_key_type = (trunnel_get_uint8(ptr)); remaining -= 1; ptr += 1; if (! (obj->auth_key_type == 0 || obj->auth_key_type == 1 || obj->auth_key_type == 2)) goto fail; /* Parse u16 auth_key_len */ CHECK_REMAINING(2, truncated); obj->auth_key_len = trunnel_ntohs(trunnel_get_uint16(ptr)); remaining -= 2; ptr += 2; /* Parse u8 auth_key[auth_key_len] */ CHECK_REMAINING(obj->auth_key_len, truncated); TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->auth_key, obj->auth_key_len, {}); obj->auth_key.n_ = obj->auth_key_len; if (obj->auth_key_len) memcpy(obj->auth_key.elts_, ptr, obj->auth_key_len); ptr += obj->auth_key_len; remaining -= obj->auth_key_len; /* Parse struct trn_cell_extension extensions */ result = trn_cell_extension_parse(&obj->extensions, ptr, remaining); if (result < 0) goto relay_fail; trunnel_assert((size_t)result <= remaining); remaining -= result; ptr += result; /* Parse u8 encrypted[] */ TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->encrypted, remaining, {}); obj->encrypted.n_ = remaining; if (remaining) memcpy(obj->encrypted.elts_, ptr, remaining); ptr += remaining; remaining -= remaining; trunnel_assert(ptr + remaining == input + len_in); return len_in - remaining; truncated: return -2; relay_fail: trunnel_assert(result < 0); return result; trunnel_alloc_failed: return -1; fail: result = -1; return result; }
/** As certs_cell_cert_parse(), but do not allocate the output object. */ static ssize_t certs_cell_cert_parse_into(certs_cell_cert_t *obj, const uint8_t *input, const size_t len_in) { const uint8_t *ptr = input; size_t remaining = len_in; ssize_t result = 0; (void)result; /* Parse u8 cert_type */ CHECK_REMAINING(1, truncated); obj->cert_type = (trunnel_get_uint8(ptr)); remaining -= 1; ptr += 1; /* Parse u16 cert_len */ CHECK_REMAINING(2, truncated); obj->cert_len = trunnel_ntohs(trunnel_get_uint16(ptr)); remaining -= 2; ptr += 2; /* Parse u8 body[cert_len] */ CHECK_REMAINING(obj->cert_len, truncated); TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->body, obj->cert_len, {}); obj->body.n_ = obj->cert_len; memcpy(obj->body.elts_, ptr, obj->cert_len); ptr += obj->cert_len; remaining -= obj->cert_len; trunnel_assert(ptr + remaining == input + len_in); return len_in - remaining; truncated: return -2; trunnel_alloc_failed: return -1; }
/** As auth_challenge_cell_parse(), but do not allocate the output * object. */ static ssize_t auth_challenge_cell_parse_into(auth_challenge_cell_t *obj, const uint8_t *input, const size_t len_in) { const uint8_t *ptr = input; size_t remaining = len_in; ssize_t result = 0; (void)result; /* Parse u8 challenge[32] */ CHECK_REMAINING(32, truncated); memcpy(obj->challenge, ptr, 32); remaining -= 32; ptr += 32; /* Parse u16 n_methods */ CHECK_REMAINING(2, truncated); obj->n_methods = trunnel_ntohs(trunnel_get_uint16(ptr)); remaining -= 2; ptr += 2; /* Parse u16 methods[n_methods] */ TRUNNEL_DYNARRAY_EXPAND(uint16_t, &obj->methods, obj->n_methods, {}); { uint16_t elt; unsigned idx; for (idx = 0; idx < obj->n_methods; ++idx) { CHECK_REMAINING(2, truncated); elt = trunnel_ntohs(trunnel_get_uint16(ptr)); remaining -= 2; ptr += 2; TRUNNEL_DYNARRAY_ADD(uint16_t, &obj->methods, elt, {}); } } trunnel_assert(ptr + remaining == input + len_in); return len_in - remaining; truncated: return -2; trunnel_alloc_failed: return -1; }
/** As ed25519_cert_extension_parse(), but do not allocate the output * object. */ static ssize_t ed25519_cert_extension_parse_into(ed25519_cert_extension_t *obj, const uint8_t *input, const size_t len_in) { const uint8_t *ptr = input; size_t remaining = len_in; ssize_t result = 0; (void)result; /* Parse u16 ext_length */ CHECK_REMAINING(2, truncated); obj->ext_length = trunnel_ntohs(trunnel_get_uint16(ptr)); remaining -= 2; ptr += 2; /* Parse u8 ext_type */ CHECK_REMAINING(1, truncated); obj->ext_type = (trunnel_get_uint8(ptr)); remaining -= 1; ptr += 1; /* Parse u8 ext_flags */ CHECK_REMAINING(1, truncated); obj->ext_flags = (trunnel_get_uint8(ptr)); remaining -= 1; ptr += 1; { size_t remaining_after; CHECK_REMAINING(obj->ext_length, truncated); remaining_after = remaining - obj->ext_length; remaining = obj->ext_length; /* Parse union un[ext_type] */ switch (obj->ext_type) { case CERTEXT_SIGNED_WITH_KEY: /* Parse u8 un_signing_key[32] */ CHECK_REMAINING(32, fail); memcpy(obj->un_signing_key, ptr, 32); remaining -= 32; ptr += 32; break; default: /* Parse u8 un_unparsed[] */ TRUNNEL_DYNARRAY_EXPAND(uint8_t, &obj->un_unparsed, remaining, {}); obj->un_unparsed.n_ = remaining; memcpy(obj->un_unparsed.elts_, ptr, remaining); ptr += remaining; remaining -= remaining; break; } if (remaining != 0) goto fail; remaining = remaining_after; } trunnel_assert(ptr + remaining == input + len_in); return len_in - remaining; truncated: return -2; trunnel_alloc_failed: return -1; fail: result = -1; return result; }