@ohos-ports/bare-buffer 3.7.1-beta.0

package/deps/libhex/src/hex.c

@@ -0,0 +1,16 @@
+#include <stdint.h>
+#include <utf.h>
+
+#include "../include/hex.h"
+
+extern int
+hex_encode_utf8(const uint8_t *buffer, size_t buffer_len, utf8_t *string, size_t *string_len);
+
+extern int
+hex_decode_utf8(const utf8_t *string, size_t string_len, uint8_t *buffer, size_t *buffer_len);
+
+extern int
+hex_encode_utf16le(const uint8_t *buffer, size_t buffer_len, utf16_t *string, size_t *string_len);
+
+extern int
+hex_decode_utf16le(const utf16_t *string, size_t string_len, uint8_t *buffer, size_t *buffer_len);

package/deps/libhex/test/CMakeLists.txt

@@ -0,0 +1,31 @@
+list(APPEND tests
+  decode
+  decode-invalid
+  decode-length
+  encode
+  encode-length
+)
+
+foreach(test IN LISTS tests)
+  add_executable(${test} ${test}.c)
+
+  target_link_libraries(
+    ${test}
+    PRIVATE
+      hex_static
+  )
+
+  add_test(
+    NAME ${test}
+    COMMAND ${test}
+    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+  )
+
+  set_tests_properties(
+    ${test}
+    PROPERTIES
+    TIMEOUT 30
+  )
+endforeach()
+
+add_subdirectory(fuzz)

package/deps/libhex/test/decode-invalid.c

@@ -0,0 +1,37 @@
+#include <assert.h>
+#include <string.h>
+#include <utf.h>
+
+#include "../include/hex.h"
+
+#define test_decode_invalid_utf8(string) \
+  { \
+    size_t string_len = strlen(string); \
+    size_t buffer_len = string_len; \
+    uint8_t buffer[buffer_len]; \
+    int err = hex_decode_utf8((utf8_t *) string, string_len, buffer, &buffer_len); \
+    assert(err != 0); \
+  };
+
+#define test_decode_invalid_utf16le(units, n) \
+  { \
+    size_t buffer_len = n; \
+    uint8_t buffer[buffer_len]; \
+    int err = hex_decode_utf16le(units, n, buffer, &buffer_len); \
+    assert(err != 0); \
+  };
+
+int
+main() {
+  test_decode_invalid_utf8("v");
+
+  // Odd-length input must be rejected
+  test_decode_invalid_utf8("abc");
+
+  utf16_t odd[3] = {'a', 'b', 'c'};
+  test_decode_invalid_utf16le(odd, 3);
+
+  // UTF-16 code units > 0xff must be rejected
+  utf16_t high[2] = {'6', 0x20ac};
+  test_decode_invalid_utf16le(high, 2);
+}

package/deps/libhex/test/decode-length.c

@@ -0,0 +1,23 @@
+#include <assert.h>
+#include <string.h>
+#include <utf.h>
+
+#include "../include/hex.h"
+
+#define test_decode_length(string, expected) \
+  { \
+    size_t string_len = strlen(string); \
+    size_t buffer_len = 0; \
+    int err = hex_decode_utf8((utf8_t *) string, string_len, NULL, &buffer_len); \
+    assert(err == 0); \
+    assert(buffer_len == expected); \
+  };
+
+int
+main() {
+  test_decode_length("61", 1);
+  test_decode_length("6162", 2);
+  test_decode_length("616263", 3);
+  test_decode_length("61626364", 4);
+  test_decode_length("6162636465", 5);
+}

package/deps/libhex/test/decode.c

@@ -0,0 +1,25 @@
+#include <assert.h>
+#include <string.h>
+#include <utf.h>
+
+#include "../include/hex.h"
+
+#define test_decode(string, expected) \
+  { \
+    size_t string_len = strlen(string); \
+    size_t buffer_len = string_len; \
+    uint8_t buffer[buffer_len]; \
+    int err = hex_decode_utf8((utf8_t *) string, string_len, buffer, &buffer_len); \
+    assert(err == 0); \
+    assert(buffer_len == strlen(expected)); \
+    assert(strncmp((char *) buffer, expected, buffer_len) == 0); \
+  };
+
+int
+main() {
+  test_decode("61", "a");
+  test_decode("6162", "ab");
+  test_decode("616263", "abc");
+  test_decode("61626364", "abcd");
+  test_decode("6162636465", "abcde");
+}

package/deps/libhex/test/encode-length.c

@@ -0,0 +1,22 @@
+#include <assert.h>
+#include <string.h>
+
+#include "../include/hex.h"
+
+#define test_encode_length(buffer, expected) \
+  { \
+    size_t buffer_len = strlen(buffer); \
+    size_t string_len = 0; \
+    int err = hex_encode_utf8((uint8_t *) buffer, buffer_len, NULL, &string_len); \
+    assert(err == 0); \
+    assert(string_len == expected); \
+  };
+
+int
+main() {
+  test_encode_length("a", 2);
+  test_encode_length("ab", 4);
+  test_encode_length("abc", 6);
+  test_encode_length("abcd", 8);
+  test_encode_length("abcde", 10);
+}

package/deps/libhex/test/encode.c

@@ -0,0 +1,25 @@
+#include <assert.h>
+#include <string.h>
+#include <utf.h>
+
+#include "../include/hex.h"
+
+#define test_encode(buffer, expected) \
+  { \
+    size_t buffer_len = strlen(buffer); \
+    size_t string_len = buffer_len * 2 + 1; \
+    char string[string_len]; \
+    int err = hex_encode_utf8((uint8_t *) buffer, buffer_len, (utf8_t *) string, &string_len); \
+    assert(err == 0); \
+    assert(string_len == strlen(expected)); \
+    assert(strncmp(string, expected, string_len) == 0); \
+  };
+
+int
+main() {
+  test_encode("a", "61");
+  test_encode("ab", "6162");
+  test_encode("abc", "616263");
+  test_encode("abcd", "61626364");
+  test_encode("abcde", "6162636465");
+}

package/deps/libhex/test/fuzz/CMakeLists.txt

@@ -0,0 +1,18 @@
+list(APPEND fuzzers
+  encode/utf8
+  encode/utf16le
+  decode/utf8
+  decode/utf16le
+)
+
+foreach(fuzzer IN LISTS fuzzers)
+  string(REPLACE "/" "_" name ${fuzzer})
+
+  add_fuzzer(fuzz_${name} ${fuzzer}.c)
+
+  target_link_libraries(
+    fuzz_${name}
+    PRIVATE
+      hex_static
+  )
+endforeach()

package/deps/libhex/test/fuzz/decode/utf16le.c

@@ -0,0 +1,53 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/hex.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Reinterpret the raw bytes as a sequence of UTF-16 code units.
+  size_t units = size / sizeof(utf16_t);
+  utf16_t *string = units > 0 ? malloc(units * sizeof(utf16_t)) : NULL;
+
+  if (string != NULL) memcpy(string, data, units * sizeof(utf16_t));
+
+  size_t buffer_len = units / 2;
+  uint8_t *buffer = buffer_len > 0 ? malloc(buffer_len) : NULL;
+
+  int err = hex_decode_utf16le(string, units, buffer, &buffer_len);
+
+  if (err == 0) {
+    assert(buffer_len == units / 2);
+
+    if (buffer_len > 0) {
+      // Re-encode the decoded bytes; the result must decode back identically.
+      size_t reencoded_len = buffer_len * 2;
+      utf16_t *reencoded = malloc(reencoded_len * sizeof(utf16_t));
+
+      err = hex_encode_utf16le(buffer, buffer_len, reencoded, &reencoded_len);
+
+      assert(err == 0);
+      assert(reencoded_len == buffer_len * 2);
+
+      size_t roundtrip_len = buffer_len;
+      uint8_t *roundtrip = malloc(roundtrip_len);
+
+      err = hex_decode_utf16le(reencoded, reencoded_len, roundtrip, &roundtrip_len);
+
+      assert(err == 0);
+      assert(roundtrip_len == buffer_len);
+      assert(memcmp(roundtrip, buffer, buffer_len) == 0);
+
+      free(roundtrip);
+      free(reencoded);
+    }
+  }
+
+  free(buffer);
+  free(string);
+
+  return 0;
+}

package/deps/libhex/test/fuzz/decode/utf8.c

@@ -0,0 +1,47 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/hex.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Decoded output is at most half the input length.
+  size_t buffer_len = size / 2;
+  uint8_t *buffer = buffer_len > 0 ? malloc(buffer_len) : NULL;
+
+  int err = hex_decode_utf8((const utf8_t *) data, size, buffer, &buffer_len);
+
+  if (err == 0) {
+    assert(buffer_len == size / 2);
+
+    if (buffer_len > 0) {
+      // Re-encode the decoded bytes; the result must decode back identically.
+      size_t string_len = buffer_len * 2;
+      utf8_t *string = malloc(string_len);
+
+      err = hex_encode_utf8(buffer, buffer_len, string, &string_len);
+
+      assert(err == 0);
+      assert(string_len == buffer_len * 2);
+
+      size_t roundtrip_len = buffer_len;
+      uint8_t *roundtrip = malloc(roundtrip_len);
+
+      err = hex_decode_utf8(string, string_len, roundtrip, &roundtrip_len);
+
+      assert(err == 0);
+      assert(roundtrip_len == buffer_len);
+      assert(memcmp(roundtrip, buffer, buffer_len) == 0);
+
+      free(roundtrip);
+      free(string);
+    }
+  }
+
+  free(buffer);
+
+  return 0;
+}

package/deps/libhex/test/fuzz/encode/utf16le.c

@@ -0,0 +1,36 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/hex.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Each input byte expands to exactly 2 hex code units.
+  size_t string_len = size * 2;
+  utf16_t *string = string_len > 0 ? malloc(string_len * sizeof(utf16_t)) : NULL;
+
+  int err = hex_encode_utf16le(data, size, string, &string_len);
+
+  assert(err == 0);
+  assert(string_len == size * 2);
+
+  if (size > 0) {
+    size_t buffer_len = size;
+    uint8_t *buffer = malloc(buffer_len);
+
+    err = hex_decode_utf16le(string, string_len, buffer, &buffer_len);
+
+    assert(err == 0);
+    assert(buffer_len == size);
+    assert(memcmp(buffer, data, size) == 0);
+
+    free(buffer);
+  }
+
+  free(string);
+
+  return 0;
+}

package/deps/libhex/test/fuzz/encode/utf8.c

@@ -0,0 +1,36 @@
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../../include/hex.h"
+
+int
+LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  // Each input byte expands to exactly 2 hex characters.
+  size_t string_len = size * 2;
+  utf8_t *string = string_len > 0 ? malloc(string_len) : NULL;
+
+  int err = hex_encode_utf8(data, size, string, &string_len);
+
+  assert(err == 0);
+  assert(string_len == size * 2);
+
+  if (size > 0) {
+    size_t buffer_len = size;
+    uint8_t *buffer = malloc(buffer_len);
+
+    err = hex_decode_utf8(string, string_len, buffer, &buffer_len);
+
+    assert(err == 0);
+    assert(buffer_len == size);
+    assert(memcmp(buffer, data, size) == 0);
+
+    free(buffer);
+  }
+
+  free(string);
+
+  return 0;
+}

package/deps/libutf/.clang-format

@@ -0,0 +1,10 @@
+AlignAfterOpenBracket: BlockIndent
+AlignConsecutiveMacros: Consecutive
+AlignEscapedNewlines: DontAlign
+AllowShortIfStatementsOnASingleLine: AllIfsAndElse
+AlwaysBreakAfterReturnType: TopLevel
+BinPackArguments: false
+BinPackParameters: false
+ContinuationIndentWidth: 2
+ColumnLimit: 0
+SpaceAfterCStyleCast: true

package/deps/libutf/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

package/deps/libutf/.github/workflows/integrate.yml

@@ -0,0 +1,45 @@
+name: Integrate
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+permissions:
+  contents: read
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    name: Security
+    steps:
+      - uses: holepunchto/actions/security-base@v1
+  lint:
+    runs-on: ubuntu-latest
+    name: Lint
+    steps:
+      - uses: holepunchto/actions/node-base@v1
+      - run: npm run lint
+  test:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: linux
+            arch: x64
+          - os: macos-latest
+            platform: darwin
+            arch: arm64
+          - os: windows-latest
+            platform: win32
+            arch: x64
+    runs-on: ${{ matrix.os }}
+    name: Test / ${{ matrix.platform }}-${{ matrix.arch }}
+    steps:
+      - uses: holepunchto/actions/bare-base@v1
+      - uses: holepunchto/actions/compile-prebuilds@v1
+        with:
+          platform: ${{ matrix.platform }}
+          arch: ${{ matrix.arch }}
+          flags: --debug
+      - run: bare-make test

package/deps/libutf/.github/workflows/nightly.yml

@@ -0,0 +1,28 @@
+name: Nightly
+on:
+  schedule:
+    - cron: '0 4 * * *'
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  fuzz:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            platform: linux
+            arch: x64
+    runs-on: ${{ matrix.os }}
+    name: Fuzz / ${{ matrix.platform }}-${{ matrix.arch }}
+    steps:
+      - uses: holepunchto/actions/bare-base@v1
+      - uses: holepunchto/actions/restore-fuzz-corpus@v1
+      - uses: holepunchto/actions/compile-prebuilds@v1
+        with:
+          platform: ${{ matrix.platform }}
+          arch: ${{ matrix.arch }}
+          flags: --debug --sanitize address --fuzz
+      - run: bare-make test
+      - uses: holepunchto/actions/save-fuzz-corpus@v1
+        if: always()

package/deps/libutf/.prettierrc

@@ -0,0 +1 @@
+"prettier-config-holepunch"

package/deps/libutf/CMakeLists.txt

@@ -0,0 +1,105 @@
+cmake_minimum_required(VERSION 3.31)
+
+find_package(cmake-harden REQUIRED PATHS node_modules/cmake-harden)
+find_package(cmake-fuzz REQUIRED PATHS node_modules/cmake-fuzz)
+
+project(utf C)
+
+add_library(utf OBJECT)
+
+harden(utf)
+
+set_target_properties(
+  utf
+  PROPERTIES
+  C_STANDARD 99
+  POSITION_INDEPENDENT_CODE ON
+)
+
+target_sources(
+  utf
+  INTERFACE
+    include/utf.h
+    include/utf/string.h
+  PRIVATE
+    src/endianness.c
+    src/endianness.h
+    src/ascii/validate.c
+    src/latin1/convert-to-utf8.c
+    src/latin1/convert-to-utf16.c
+    src/latin1/convert-to-utf32.c
+    src/latin1/length-from-utf8.c
+    src/latin1/length-from-utf16.c
+    src/latin1/length-from-utf32.c
+    src/utf8/convert-to-latin1.c
+    src/utf8/convert-to-utf16.c
+    src/utf8/convert-to-utf32.c
+    src/utf8/length-from-latin1.c
+    src/utf8/length-from-utf16.c
+    src/utf8/length-from-utf32.c
+    src/utf8/string.c
+    src/utf8/validate.c
+    src/utf16/convert-to-latin1.c
+    src/utf16/convert-to-utf8.c
+    src/utf16/convert-to-utf32.c
+    src/utf16/length-from-latin1.c
+    src/utf16/length-from-utf8.c
+    src/utf16/length-from-utf32.c
+    src/utf16/validate.c
+    src/utf32/convert-to-latin1.c
+    src/utf32/convert-to-utf8.c
+    src/utf32/convert-to-utf16.c
+    src/utf32/length-from-latin1.c
+    src/utf32/length-from-utf8.c
+    src/utf32/length-from-utf16.c
+    src/utf32/string.c
+    src/utf32/validate.c
+)
+
+target_include_directories(
+  utf
+  PUBLIC
+    include
+)
+
+add_library(utf_shared SHARED)
+
+set_target_properties(
+  utf_shared
+  PROPERTIES
+  OUTPUT_NAME utf
+  WINDOWS_EXPORT_ALL_SYMBOLS ON
+)
+
+target_link_libraries(
+  utf_shared
+  PUBLIC
+    utf
+)
+
+add_library(utf_static STATIC)
+
+set_target_properties(
+  utf_static
+  PROPERTIES
+  OUTPUT_NAME utf
+  PREFIX lib
+)
+
+target_link_libraries(
+  utf_static
+  PUBLIC
+    utf
+)
+
+install(TARGETS utf_shared utf_static)
+
+install(FILES include/utf.h DESTINATION include)
+
+install(DIRECTORY include/utf DESTINATION include)
+
+if(PROJECT_IS_TOP_LEVEL)
+  enable_testing()
+
+  add_subdirectory(test)
+endif()