react-native-queue-player 1.0.0

package/android/src/main/cpp/third_party/openssl/include/openssl/x509v3err.h

@@ -0,0 +1,97 @@
+/*
+ * Generated by util/mkerr.pl DO NOT EDIT
+ * Copyright 1995-2025 The OpenSSL Project Authors. All Rights Reserved.
+ *
+ * Licensed under the Apache License 2.0 (the "License").  You may not use
+ * this file except in compliance with the License.  You can obtain a copy
+ * in the file LICENSE in the source distribution or at
+ * https://www.openssl.org/source/license.html
+ */
+
+#ifndef OPENSSL_X509V3ERR_H
+# define OPENSSL_X509V3ERR_H
+# pragma once
+
+# include <openssl/opensslconf.h>
+# include <openssl/symhacks.h>
+# include <openssl/cryptoerr_legacy.h>
+
+
+
+/*
+ * X509V3 reason codes.
+ */
+# define X509V3_R_BAD_IP_ADDRESS                          118
+# define X509V3_R_BAD_OBJECT                              119
+# define X509V3_R_BAD_OPTION                              170
+# define X509V3_R_BAD_VALUE                               171
+# define X509V3_R_BN_DEC2BN_ERROR                         100
+# define X509V3_R_BN_TO_ASN1_INTEGER_ERROR                101
+# define X509V3_R_DIRNAME_ERROR                           149
+# define X509V3_R_DISTPOINT_ALREADY_SET                   160
+# define X509V3_R_DUPLICATE_ZONE_ID                       133
+# define X509V3_R_EMPTY_KEY_USAGE                         169
+# define X509V3_R_ERROR_CONVERTING_ZONE                   131
+# define X509V3_R_ERROR_CREATING_EXTENSION                144
+# define X509V3_R_ERROR_IN_EXTENSION                      128
+# define X509V3_R_EXPECTED_A_SECTION_NAME                 137
+# define X509V3_R_EXTENSION_EXISTS                        145
+# define X509V3_R_EXTENSION_NAME_ERROR                    115
+# define X509V3_R_EXTENSION_NOT_FOUND                     102
+# define X509V3_R_EXTENSION_SETTING_NOT_SUPPORTED         103
+# define X509V3_R_EXTENSION_VALUE_ERROR                   116
+# define X509V3_R_ILLEGAL_EMPTY_EXTENSION                 151
+# define X509V3_R_INCORRECT_POLICY_SYNTAX_TAG             152
+# define X509V3_R_INVALID_ASNUMBER                        162
+# define X509V3_R_INVALID_ASRANGE                         163
+# define X509V3_R_INVALID_BOOLEAN_STRING                  104
+# define X509V3_R_INVALID_CERTIFICATE                     158
+# define X509V3_R_INVALID_EMPTY_NAME                      108
+# define X509V3_R_INVALID_EXTENSION_STRING                105
+# define X509V3_R_INVALID_INHERITANCE                     165
+# define X509V3_R_INVALID_IPADDRESS                       166
+# define X509V3_R_INVALID_MULTIPLE_RDNS                   161
+# define X509V3_R_INVALID_NAME                            106
+# define X509V3_R_INVALID_NULL_ARGUMENT                   107
+# define X509V3_R_INVALID_NULL_VALUE                      109
+# define X509V3_R_INVALID_NUMBER                          140
+# define X509V3_R_INVALID_NUMBERS                         141
+# define X509V3_R_INVALID_OBJECT_IDENTIFIER               110
+# define X509V3_R_INVALID_OPTION                          138
+# define X509V3_R_INVALID_POLICY_IDENTIFIER               134
+# define X509V3_R_INVALID_PROXY_POLICY_SETTING            153
+# define X509V3_R_INVALID_PURPOSE                         146
+# define X509V3_R_INVALID_SAFI                            164
+# define X509V3_R_INVALID_SECTION                         135
+# define X509V3_R_INVALID_SYNTAX                          143
+# define X509V3_R_ISSUER_DECODE_ERROR                     126
+# define X509V3_R_MISSING_VALUE                           124
+# define X509V3_R_NEED_ORGANIZATION_AND_NUMBERS           142
+# define X509V3_R_NEGATIVE_PATHLEN                        168
+# define X509V3_R_NO_CONFIG_DATABASE                      136
+# define X509V3_R_NO_ISSUER_CERTIFICATE                   121
+# define X509V3_R_NO_ISSUER_DETAILS                       127
+# define X509V3_R_NO_POLICY_IDENTIFIER                    139
+# define X509V3_R_NO_PROXY_CERT_POLICY_LANGUAGE_DEFINED   154
+# define X509V3_R_NO_PUBLIC_KEY                           114
+# define X509V3_R_NO_SUBJECT_DETAILS                      125
+# define X509V3_R_OPERATION_NOT_DEFINED                   148
+# define X509V3_R_OTHERNAME_ERROR                         147
+# define X509V3_R_POLICY_LANGUAGE_ALREADY_DEFINED         155
+# define X509V3_R_POLICY_PATH_LENGTH                      156
+# define X509V3_R_POLICY_PATH_LENGTH_ALREADY_DEFINED      157
+# define X509V3_R_POLICY_WHEN_PROXY_LANGUAGE_REQUIRES_NO_POLICY 159
+# define X509V3_R_PURPOSE_NOT_UNIQUE                      173
+# define X509V3_R_SECTION_NOT_FOUND                       150
+# define X509V3_R_UNABLE_TO_GET_ISSUER_DETAILS            122
+# define X509V3_R_UNABLE_TO_GET_ISSUER_KEYID              123
+# define X509V3_R_UNKNOWN_BIT_STRING_ARGUMENT             111
+# define X509V3_R_UNKNOWN_EXTENSION                       129
+# define X509V3_R_UNKNOWN_EXTENSION_NAME                  130
+# define X509V3_R_UNKNOWN_OPTION                          120
+# define X509V3_R_UNKNOWN_VALUE                           172
+# define X509V3_R_UNSUPPORTED_OPTION                      117
+# define X509V3_R_UNSUPPORTED_TYPE                        167
+# define X509V3_R_USER_TOO_LONG                           132
+
+#endif

package/android/src/main/cpp/third_party/pair_ap/pair-internal.h

@@ -0,0 +1,390 @@
+#include <stdint.h>
+#include <stdbool.h>
+#include <sodium.h>
+
+#include "pair.h"
+
+#define RETURN_ERROR(s, m) \
+  do { handle->status = (s); handle->errmsg = (m); goto error; } while(0)
+
+
+struct SRPUser;
+struct SRPVerifier;
+
+struct pair_client_setup_context
+{
+  struct SRPUser *user;
+
+  char *pin;
+  char device_id[PAIR_AP_DEVICE_ID_LEN_MAX];
+
+  pair_cb add_cb;
+  void *add_cb_arg;
+
+  uint8_t public_key[crypto_sign_PUBLICKEYBYTES];
+  uint8_t private_key[crypto_sign_SECRETKEYBYTES];
+
+  const uint8_t *pkA;
+  int pkA_len;
+
+  uint8_t *pkB;
+  uint64_t pkB_len;
+
+  const uint8_t *M1;
+  int M1_len;
+
+  uint8_t *M2;
+  uint64_t M2_len;
+
+  uint8_t *salt;
+  uint64_t salt_len;
+
+  // We don't actually use the server's epk and authtag for anything
+  uint8_t *epk;
+  uint64_t epk_len;
+  uint8_t *authtag;
+  uint64_t authtag_len;
+};
+
+struct pair_server_setup_context
+{
+  struct SRPVerifier *verifier;
+
+  char *pin;
+  char device_id[PAIR_AP_DEVICE_ID_LEN_MAX];
+
+  pair_cb add_cb;
+  void *add_cb_arg;
+
+  uint8_t public_key[crypto_sign_PUBLICKEYBYTES];
+  uint8_t private_key[crypto_sign_SECRETKEYBYTES];
+
+  bool is_transient;
+
+  uint8_t *pkA;
+  uint64_t pkA_len;
+
+  uint8_t *pkB;
+  int pkB_len;
+
+  uint8_t *b;
+  int b_len;
+
+  uint8_t *M1;
+  uint64_t M1_len;
+
+  const uint8_t *M2;
+  int M2_len;
+
+  uint8_t *v;
+  int v_len;
+
+  uint8_t *salt;
+  int salt_len;
+};
+
+enum pair_status
+{
+  PAIR_STATUS_IN_PROGRESS,
+  PAIR_STATUS_COMPLETED,
+  PAIR_STATUS_AUTH_FAILED,
+  PAIR_STATUS_INVALID,
+};
+
+struct pair_setup_context
+{
+  struct pair_definition *type;
+
+  enum pair_status status;
+  const char *errmsg;
+
+  struct pair_result result;
+  char result_str[256]; // Holds the hex string version of the keys that pair_verify_new() needs
+
+  // Hex-formatet concatenation of public + private, 0-terminated
+  char auth_key[2 * (crypto_sign_PUBLICKEYBYTES + crypto_sign_SECRETKEYBYTES) + 1];
+
+  union pair_setup_union
+  {
+    struct pair_client_setup_context client;
+    struct pair_server_setup_context server;
+  } sctx;
+};
+
+struct pair_client_verify_context
+{
+  char device_id[PAIR_AP_DEVICE_ID_LEN_MAX];
+
+  // These are the keys that were registered with the server in pair-setup
+  uint8_t client_public_key[crypto_sign_PUBLICKEYBYTES]; // 32
+  uint8_t client_private_key[crypto_sign_SECRETKEYBYTES]; // 64
+
+  bool verify_server_signature;
+  uint8_t server_fruit_public_key[64]; // Not sure why it has this length in fruit mode
+  uint8_t server_public_key[crypto_sign_PUBLICKEYBYTES]; // 32
+
+  // For establishing the shared secret for encrypted communication
+  uint8_t client_eph_public_key[crypto_box_PUBLICKEYBYTES]; // 32
+  uint8_t client_eph_private_key[crypto_box_SECRETKEYBYTES]; // 32
+
+  uint8_t server_eph_public_key[crypto_box_PUBLICKEYBYTES]; // 32
+
+  uint8_t shared_secret[crypto_scalarmult_BYTES]; // 32
+};
+
+struct pair_server_verify_context
+{
+  char device_id[PAIR_AP_DEVICE_ID_LEN_MAX];
+
+  // Same keys as used for pair-setup, derived from device_id
+  uint8_t server_public_key[crypto_sign_PUBLICKEYBYTES]; // 32
+  uint8_t server_private_key[crypto_sign_SECRETKEYBYTES]; // 64
+
+  bool verify_client_signature;
+  pair_cb get_cb;
+  void *get_cb_arg;
+
+  // For establishing the shared secret for encrypted communication
+  uint8_t server_eph_public_key[crypto_box_PUBLICKEYBYTES]; // 32
+  uint8_t server_eph_private_key[crypto_box_SECRETKEYBYTES]; // 32
+
+  uint8_t client_eph_public_key[crypto_box_PUBLICKEYBYTES]; // 32
+
+  uint8_t shared_secret[crypto_scalarmult_BYTES]; // 32
+};
+
+struct pair_verify_context
+{
+  struct pair_definition *type;
+
+  enum pair_status status;
+  const char *errmsg;
+
+  struct pair_result result;
+
+  union pair_verify_union
+  {
+    struct pair_client_verify_context client;
+    struct pair_server_verify_context server;
+  } vctx;
+};
+
+struct pair_cipher_context
+{
+  struct pair_definition *type;
+
+  uint8_t encryption_key[32];
+  uint8_t decryption_key[32];
+
+  uint64_t encryption_counter;
+  uint64_t decryption_counter;
+
+  // For rollback
+  uint64_t encryption_counter_prev;
+  uint64_t decryption_counter_prev;
+
+  const char *errmsg;
+};
+
+struct pair_definition
+{
+  int (*pair_setup_new)(struct pair_setup_context *sctx, const char *pin, pair_cb add_cb, void *cb_arg, const char *device_id);
+  void (*pair_setup_free)(struct pair_setup_context *sctx);
+  int (*pair_setup_result)(struct pair_setup_context *sctx);
+
+  uint8_t *(*pair_setup_request1)(size_t *len, struct pair_setup_context *sctx);
+  uint8_t *(*pair_setup_request2)(size_t *len, struct pair_setup_context *sctx);
+  uint8_t *(*pair_setup_request3)(size_t *len, struct pair_setup_context *sctx);
+
+  int (*pair_setup_response1)(struct pair_setup_context *sctx, const uint8_t *in, size_t in_len);
+  int (*pair_setup_response2)(struct pair_setup_context *sctx, const uint8_t *in, size_t in_len);
+  int (*pair_setup_response3)(struct pair_setup_context *sctx, const uint8_t *in, size_t in_len);
+
+  int (*pair_verify_new)(struct pair_verify_context *vctx, const char *client_setup_keys, pair_cb cb, void *cb_arg, const char *device_id);
+  void (*pair_verify_free)(struct pair_verify_context *vctx);
+  int (*pair_verify_result)(struct pair_verify_context *vctx);
+
+  uint8_t *(*pair_verify_request1)(size_t *len, struct pair_verify_context *vctx);
+  uint8_t *(*pair_verify_request2)(size_t *len, struct pair_verify_context *vctx);
+
+  int (*pair_verify_response1)(struct pair_verify_context *vctx, const uint8_t *in, size_t in_len);
+  int (*pair_verify_response2)(struct pair_verify_context *vctx, const uint8_t *in, size_t in_len);
+
+  int (*pair_add)(uint8_t **out, size_t *out_len, pair_cb cb, void *cb_arg, const uint8_t *in, size_t in_len);
+  int (*pair_remove)(uint8_t **out, size_t *out_len, pair_cb cb, void *cb_arg, const uint8_t *in, size_t in_len);
+  int (*pair_list)(uint8_t **out, size_t *out_len, pair_list_cb cb, void *cb_arg, const uint8_t *in, size_t in_len);
+
+  struct pair_cipher_context *(*pair_cipher_new)(struct pair_definition *type, int channel, const uint8_t *shared_secret, size_t shared_secret_len);
+  void (*pair_cipher_free)(struct pair_cipher_context *cctx);
+
+  ssize_t (*pair_encrypt)(uint8_t **ciphertext, size_t *ciphertext_len, const uint8_t *plaintext, size_t plaintext_len, struct pair_cipher_context *cctx);
+  ssize_t (*pair_decrypt)(uint8_t **plaintext, size_t *plaintext_len, const uint8_t *ciphertext, size_t ciphertext_len, struct pair_cipher_context *cctx);
+
+  int (*pair_state_get)(const char **errmsg, const uint8_t *in, size_t in_len);
+  void (*pair_public_key_get)(uint8_t server_public_key[32], const char *device_id);
+};
+
+
+/* ----------------------------- INITIALIZATION ---------------------------- */
+
+bool
+is_initialized(void);
+
+
+/* -------------------- GCRYPT AND OPENSSL COMPABILITY --------------------- */
+/*                   partly borrowed from ffmpeg (rtmpdh.c)                  */
+
+#if CONFIG_GCRYPT
+#include <gcrypt.h>
+#define SHA512_DIGEST_LENGTH 64
+#define bnum_new(bn)                                            \
+    do {                                                        \
+        if (!gcry_control(GCRYCTL_INITIALIZATION_FINISHED_P)) { \
+            if (!gcry_check_version("1.5.4"))                   \
+                abort();                                        \
+            gcry_control(GCRYCTL_DISABLE_SECMEM, 0);            \
+            gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);   \
+        }                                                       \
+        bn = gcry_mpi_new(1);                                   \
+    } while (0)
+#define bnum_free(bn)                 gcry_mpi_release(bn)
+#define bnum_num_bytes(bn)            (gcry_mpi_get_nbits(bn) + 7) / 8
+#define bnum_is_zero(bn)              (gcry_mpi_cmp_ui(bn, (unsigned long)0) == 0)
+#define bnum_bn2bin(bn, buf, len)     gcry_mpi_print(GCRYMPI_FMT_USG, buf, len, NULL, bn)
+#define bnum_bin2bn(bn, buf, len)     gcry_mpi_scan(&bn, GCRYMPI_FMT_USG, buf, len, NULL)
+#define bnum_hex2bn(bn, buf)          gcry_mpi_scan(&bn, GCRYMPI_FMT_HEX, buf, 0, 0)
+#define bnum_random(bn, num_bits)     gcry_mpi_randomize(bn, num_bits, GCRY_WEAK_RANDOM)
+#define bnum_add(bn, a, b)            gcry_mpi_add(bn, a, b)
+#define bnum_sub(bn, a, b)            gcry_mpi_sub(bn, a, b)
+#define bnum_mul(bn, a, b)            gcry_mpi_mul(bn, a, b)
+#define bnum_mod(bn, a, b)            gcry_mpi_mod(bn, a, b)
+typedef gcry_mpi_t bnum;
+__attribute__((unused)) static void bnum_modexp(bnum bn, bnum y, bnum q, bnum p)
+{
+  gcry_mpi_powm(bn, y, q, p);
+}
+__attribute__((unused)) static void bnum_modadd(bnum bn, bnum a, bnum b, bnum m)
+{
+  gcry_mpi_addm(bn, a, b, m);
+}
+#elif CONFIG_OPENSSL
+#include <openssl/crypto.h>
+#include <openssl/bn.h>
+#include <openssl/rand.h>
+#include <openssl/sha.h>
+#include <openssl/evp.h>
+#define bnum_new(bn)                  bn = BN_new()
+#define bnum_free(bn)                 BN_free(bn)
+#define bnum_num_bytes(bn)            BN_num_bytes(bn)
+#define bnum_is_zero(bn)              BN_is_zero(bn)
+#define bnum_bn2bin(bn, buf, len)     BN_bn2bin(bn, buf)
+#define bnum_bin2bn(bn, buf, len)     bn = BN_bin2bn(buf, len, 0)
+#define bnum_hex2bn(bn, buf)          BN_hex2bn(&bn, buf)
+#define bnum_random(bn, num_bits)     BN_rand(bn, num_bits, 0, 0)
+#define bnum_add(bn, a, b)            BN_add(bn, a, b)
+#define bnum_sub(bn, a, b)            BN_sub(bn, a, b)
+typedef BIGNUM* bnum;
+__attribute__((unused)) static void bnum_mul(bnum bn, bnum a, bnum b)
+{
+  // No error handling
+  BN_CTX *ctx = BN_CTX_new();
+  BN_mul(bn, a, b, ctx);
+  BN_CTX_free(ctx);
+}
+__attribute__((unused)) static void bnum_mod(bnum bn, bnum a, bnum b)
+{
+  // No error handling
+  BN_CTX *ctx = BN_CTX_new();
+  BN_mod(bn, a, b, ctx);
+  BN_CTX_free(ctx);
+}
+__attribute__((unused)) static void bnum_modexp(bnum bn, bnum y, bnum q, bnum p)
+{
+  // No error handling
+  BN_CTX *ctx = BN_CTX_new();
+  BN_mod_exp(bn, y, q, p, ctx);
+  BN_CTX_free(ctx);
+}
+__attribute__((unused)) static void bnum_modadd(bnum bn, bnum a, bnum b, bnum m)
+{
+  // No error handling
+  BN_CTX *ctx = BN_CTX_new();
+  BN_mod_add(bn, a, b, m, ctx);
+  BN_CTX_free(ctx);
+}
+#endif
+
+
+/* -------------------------- SHARED HASHING HELPERS ------------------------ */
+
+#ifdef CONFIG_OPENSSL
+enum hash_alg
+{
+  HASH_SHA1,
+  HASH_SHA224,
+  HASH_SHA256,
+  HASH_SHA384,
+  HASH_SHA512,
+};
+#elif CONFIG_GCRYPT
+enum hash_alg
+{
+  HASH_SHA1 = GCRY_MD_SHA1,
+  HASH_SHA224 = GCRY_MD_SHA224,
+  HASH_SHA256 = GCRY_MD_SHA256,
+  HASH_SHA384 = GCRY_MD_SHA384,
+  HASH_SHA512 = GCRY_MD_SHA512,
+};
+#endif
+
+#if CONFIG_OPENSSL
+typedef union
+{
+  SHA_CTX    sha;
+  SHA256_CTX sha256;
+  SHA512_CTX sha512;
+} HashCTX;
+#elif CONFIG_GCRYPT
+typedef gcry_md_hd_t HashCTX;
+#endif
+
+int
+hash_init(enum hash_alg alg, HashCTX *c);
+
+int
+hash_update(enum hash_alg alg, HashCTX *c, const void *data, size_t len);
+
+int
+hash_final(enum hash_alg alg, HashCTX *c, unsigned char *md);
+
+unsigned char *
+hash(enum hash_alg alg, const unsigned char *d, size_t n, unsigned char *md);
+
+int
+hash_length(enum hash_alg alg);
+
+int
+hash_ab(enum hash_alg alg, unsigned char *md, const unsigned char *m1, int m1_len, const unsigned char *m2, int m2_len);
+
+bnum
+H_nn_pad(enum hash_alg alg, const bnum n1, const bnum n2, int padded_len);
+
+bnum
+H_ns(enum hash_alg alg, const bnum n, const unsigned char *bytes, int len_bytes);
+
+void
+update_hash_n(enum hash_alg alg, HashCTX *ctx, const bnum n);
+
+void
+hash_num(enum hash_alg alg, const bnum n, unsigned char *dest);
+
+
+/* ----------------------------- OTHER HELPERS -------------------------------*/
+
+#ifdef DEBUG_PAIR
+void
+hexdump(const char *msg, uint8_t *mem, size_t len);
+
+void
+bnum_dump(const char *msg, bnum n);
+#endif

package/android/src/main/cpp/third_party/pair_ap/pair-tlv.c

@@ -0,0 +1,221 @@
+/*
+ * TLV helpers are adapted from ESP homekit:
+ *    <https://github.com/maximkulkin/esp-homekit>
+ *
+ * The MIT License (MIT)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is furnished to do
+ * so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "pair-tlv.h"
+#include "pair-internal.h"
+
+
+static int
+tlv_add_value_(pair_tlv_values_t *values, uint8_t type, uint8_t *value, size_t size) {
+    pair_tlv_t *tlv = malloc(sizeof(pair_tlv_t));
+    if (!tlv) {
+        return PAIR_TLV_ERROR_MEMORY;
+    }
+    tlv->type = type;
+    tlv->size = size;
+    tlv->value = value;
+    tlv->next = NULL;
+
+    if (!values->head) {
+        values->head = tlv;
+    } else {
+        pair_tlv_t *t = values->head;
+        while (t->next) {
+            t = t->next;
+        }
+        t->next = tlv;
+    }
+
+    return 0;
+}
+
+
+pair_tlv_values_t *
+pair_tlv_new() {
+    pair_tlv_values_t *values = malloc(sizeof(pair_tlv_values_t));
+    if (!values)
+        return NULL;
+
+    values->head = NULL;
+    return values;
+}
+
+void
+pair_tlv_free(pair_tlv_values_t *values) {
+    if (!values)
+        return;
+
+    pair_tlv_t *t = values->head;
+    while (t) {
+        pair_tlv_t *t2 = t;
+        t = t->next;
+        if (t2->value)
+            free(t2->value);
+        free(t2);
+    }
+    free(values);
+}
+
+int
+pair_tlv_add_value(pair_tlv_values_t *values, uint8_t type, const uint8_t *value, size_t size) {
+    uint8_t *data = NULL;
+    int ret;
+    if (size) {
+        data = malloc(size);
+        if (!data) {
+            return PAIR_TLV_ERROR_MEMORY;
+        }
+        memcpy(data, value, size);
+    }
+    ret = tlv_add_value_(values, type, data, size);
+    if (ret < 0)
+        free(data);
+    return ret;
+}
+
+pair_tlv_t *
+pair_tlv_get_value(const pair_tlv_values_t *values, uint8_t type) {
+    pair_tlv_t *t = values->head;
+    while (t) {
+        if (t->type == type)
+            return t;
+        t = t->next;
+    }
+    return NULL;
+}
+
+int
+pair_tlv_format(const pair_tlv_values_t *values, uint8_t *buffer, size_t *size) {
+    size_t required_size = 0;
+    pair_tlv_t *t = values->head;
+    while (t) {
+        required_size += t->size + 2 * ((t->size + 254) / 255);
+        t = t->next;
+    }
+
+    if (*size < required_size) {
+        *size = required_size;
+        return PAIR_TLV_ERROR_INSUFFICIENT_SIZE;
+    }
+
+    *size = required_size;
+
+    t = values->head;
+    while (t) {
+        uint8_t *data = t->value;
+        if (!t->size) {
+            buffer[0] = t->type;
+            buffer[1] = 0;
+            buffer += 2;
+            t = t->next;
+            continue;
+        }
+
+        size_t remaining = t->size;
+
+        while (remaining) {
+            buffer[0] = t->type;
+            size_t chunk_size = (remaining > 255) ? 255 : remaining;
+            buffer[1] = chunk_size;
+            memcpy(&buffer[2], data, chunk_size);
+            remaining -= chunk_size;
+            buffer += chunk_size + 2;
+            data += chunk_size;
+        }
+
+        t = t->next;
+    }
+
+    return 0;
+}
+
+int
+pair_tlv_parse(const uint8_t *buffer, size_t length, pair_tlv_values_t *values) {
+    size_t i = 0;
+    int ret;
+    while (i < length) {
+        uint8_t type = buffer[i];
+        size_t size = 0;
+        uint8_t *data = NULL;
+
+        // scan TLVs to accumulate total size of subsequent TLVs with same type (chunked data)
+        size_t j = i;
+        while (j < length && buffer[j] == type && buffer[j+1] == 255) {
+            size_t chunk_size = buffer[j+1];
+            size += chunk_size;
+            j += chunk_size + 2;
+        }
+        if (j < length && buffer[j] == type) {
+            size_t chunk_size = buffer[j+1];
+            size += chunk_size;
+        }
+
+        // allocate memory to hold all pieces of chunked data and copy data there
+        if (size != 0) {
+            data = malloc(size);
+            if (!data)
+                return PAIR_TLV_ERROR_MEMORY;
+
+            uint8_t *p = data;
+
+            size_t remaining = size;
+            while (remaining) {
+                size_t chunk_size = buffer[i+1];
+                memcpy(p, &buffer[i+2], chunk_size);
+                p += chunk_size;
+                i += chunk_size + 2;
+                remaining -= chunk_size;
+            }
+        }
+
+        ret = tlv_add_value_(values, type, data, size);
+        if (ret < 0) {
+            free(data);
+            return ret;
+        }
+    }
+
+    return 0;
+}
+
+#ifdef DEBUG_PAIR
+void
+pair_tlv_debug(const pair_tlv_values_t *values)
+{
+  printf("Received TLV values\n");
+  for (pair_tlv_t *t=values->head; t; t=t->next)
+    {
+      printf("Type %d value (%zu bytes): \n", t->type, t->size);
+      hexdump("", t->value, t->size);
+    }
+}
+#endif
+