visaljs 0.0.2 → 0.0.3

package/runtime/third_party/boringssl/crypto/bio/socket.cc

@@ -0,0 +1,210 @@
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/bio.h>
+
+#if !defined(OPENSSL_NO_SOCK)
+
+#include <fcntl.h>
+#include <string.h>
+#include <limits.h>
+
+#include <algorithm>
+
+#if !defined(OPENSSL_WINDOWS)
+#include <unistd.h>
+#else
+#include <winsock2.h>
+OPENSSL_MSVC_PRAGMA(comment(lib, "Ws2_32.lib"))
+#endif
+
+#include "internal.h"
+
+
+using namespace bssl;
+
+#if !defined(OPENSSL_WINDOWS)
+static int closesocket(int sock) { return close(sock); }
+#endif
+
+static int sock_free(BIO *bio) {
+  if (BIO_get_shutdown(bio)) {
+    if (BIO_get_init(bio)) {
+      closesocket(FromOpaque(bio)->num);
+    }
+    BIO_set_init(bio, 0);
+    BIO_clear_retry_flags(bio);
+  }
+  return 1;
+}
+
+static int sock_read(BIO *b, char *out, int outl) {
+  bio_clear_socket_error();
+#if defined(OPENSSL_WINDOWS)
+  int ret = recv(FromOpaque(b)->num, out, outl, 0);
+#else
+  int ret = (int)read(FromOpaque(b)->num, out, outl);
+#endif
+  BIO_clear_retry_flags(b);
+  if (ret <= 0) {
+    if (bio_socket_should_retry(ret)) {
+      BIO_set_retry_read(b);
+    }
+  }
+  return ret;
+}
+
+static int sock_write_ex(BIO *b, const char *in, size_t inl,
+                         size_t *out_written) {
+  bio_clear_socket_error();
+#if defined(OPENSSL_WINDOWS)
+  inl = std::min(inl, size_t{INT_MAX});
+  int ret = send(FromOpaque(b)->num, in, static_cast<int>(inl), 0);
+#else
+  ssize_t ret = write(FromOpaque(b)->num, in, inl);
+#endif
+  BIO_clear_retry_flags(b);
+  if (ret <= 0) {
+    if (bio_socket_should_retry(ret)) {
+      BIO_set_retry_write(b);
+    }
+    return 0;
+  }
+
+  *out_written = ret;
+  return 1;
+}
+
+static long sock_ctrl(BIO *b, int cmd, long num, void *ptr) {
+  switch (cmd) {
+    case BIO_C_SET_FD:
+      sock_free(b);
+      FromOpaque(b)->num = *static_cast<int *>(ptr);
+      BIO_set_shutdown(b, static_cast<int>(num));
+      BIO_set_init(b, 1);
+      return 1;
+    case BIO_C_GET_FD:
+      if (BIO_get_init(b)) {
+        int *out = static_cast<int *>(ptr);
+        if (out != nullptr) {
+          *out = FromOpaque(b)->num;
+        }
+        return FromOpaque(b)->num;
+      }
+      return -1;
+    case BIO_CTRL_GET_CLOSE:
+      return BIO_get_shutdown(b);
+    case BIO_CTRL_SET_CLOSE:
+      BIO_set_shutdown(b, static_cast<int>(num));
+      return 1;
+    case BIO_CTRL_FLUSH:
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+static const BIO_METHOD methods_sockp = {
+    BIO_TYPE_SOCKET,
+    /*bwrite=*/nullptr, sock_write_ex,
+    sock_read,          nullptr /* gets, */,
+    sock_ctrl,          nullptr /* create */,
+    sock_free,          nullptr /* callback_ctrl */,
+};
+
+const BIO_METHOD *BIO_s_socket() { return &methods_sockp; }
+
+BIO *BIO_new_socket(int fd, int close_flag) {
+  BIO *ret;
+
+  ret = BIO_new(BIO_s_socket());
+  if (ret == nullptr) {
+    return nullptr;
+  }
+  BIO_set_fd(ret, fd, close_flag);
+  return ret;
+}
+
+// These functions are provided solely for compatibility with software that
+// tries to copy and then modify `BIO_s_socket`. See bio.h for details.
+// PostgreSQL's use makes several fragile assumptions on `BIO_s_socket`:
+//
+// - We do not store anything in `BIO_set_data`. (Broken in upstream OpenSSL,
+//   which broke PostgreSQL.)
+// - We do not store anything in `BIO_set_app_data`.
+// - `BIO_s_socket` is implemented internally using the non-`size_t`-clean
+//   I/O functions rather than the `size_t`-clean ones.
+// - `BIO_METHOD` never gains another function pointer that is used in concert
+//   with any of the functions here.
+//
+// Some other projects doing similar things use `BIO_meth_get_read` and
+// `BIO_meth_get_write` and in turn assume that `BIO_s_socket` has not been
+// ported to the `size_t`-clean `BIO_read_ex` and `BIO_write_ex`. (Not yet
+// implemented in BoringSSL.)
+//
+// This is hopelessly fragile. PostgreSQL 18 will include a fix to stop using
+// these APIs, but older versions and other software remain impacted, so we
+// implement these functions, but only support `BIO_s_socket`. For now they just
+// return the underlying functions, but if we ever need to break the above
+// assumptions, we can return an older, frozen version of `BIO_s_socket`.
+// Limiting to exactly one allowed `BIO_METHOD` lets us do this.
+//
+// These functions are also deprecated in upstream OpenSSL. See
+// https://github.com/openssl/openssl/issues/26047
+//
+// TODO(davidben): Once Folly and all versions of PostgreSQL we care about are
+// updated or patched, remove these functions.
+
+int (*BIO_meth_get_write(const BIO_METHOD *method))(BIO *, const char *, int) {
+  BSSL_CHECK(method == BIO_s_socket());
+  return method->bwrite;
+}
+
+int (*BIO_meth_get_read(const BIO_METHOD *method))(BIO *, char *, int) {
+  BSSL_CHECK(method == BIO_s_socket());
+  return method->bread;
+}
+
+int (*BIO_meth_get_gets(const BIO_METHOD *method))(BIO *, char *, int) {
+  BSSL_CHECK(method == BIO_s_socket());
+  return method->bgets;
+}
+
+int (*BIO_meth_get_puts(const BIO_METHOD *method))(BIO *, const char *) {
+  BSSL_CHECK(method == BIO_s_socket());
+  return nullptr;
+}
+
+long (*BIO_meth_get_ctrl(const BIO_METHOD *method))(BIO *, int, long, void *) {
+  BSSL_CHECK(method == BIO_s_socket());
+  return method->ctrl;
+}
+
+int (*BIO_meth_get_create(const BIO_METHOD *method))(BIO *) {
+  BSSL_CHECK(method == BIO_s_socket());
+  return method->create;
+}
+
+int (*BIO_meth_get_destroy(const BIO_METHOD *method))(BIO *) {
+  BSSL_CHECK(method == BIO_s_socket());
+  return method->destroy;
+}
+
+long (*BIO_meth_get_callback_ctrl(const BIO_METHOD *method))(BIO *, int,
+                                                             bio_info_cb) {
+  BSSL_CHECK(method == BIO_s_socket());
+  return method->callback_ctrl;
+}
+
+#endif  // OPENSSL_NO_SOCK

package/runtime/third_party/boringssl/crypto/bio/socket_helper.cc

@@ -0,0 +1,179 @@
+// Copyright 2014 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if defined(__linux__)
+#undef _POSIX_C_SOURCE
+#define _POSIX_C_SOURCE 200112L
+#endif
+
+#include <openssl/bio.h>
+#include <openssl/err.h>
+
+#if !defined(OPENSSL_NO_SOCK)
+
+#include <fcntl.h>
+#include <string.h>
+#include <sys/types.h>
+
+#if !defined(OPENSSL_WINDOWS)
+#include <errno.h>
+#include <netdb.h>
+#include <poll.h>
+#include <unistd.h>
+#else
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#endif
+
+#include "internal.h"
+#include "../internal.h"
+
+
+BSSL_NAMESPACE_BEGIN
+
+int bio_ip_and_port_to_socket_and_addr(int *out_sock,
+                                       struct sockaddr_storage *out_addr,
+                                       socklen_t *out_addr_length,
+                                       const char *hostname,
+                                       const char *port_str) {
+  struct addrinfo hint, *result, *cur;
+  int ret;
+
+  *out_sock = -1;
+
+  OPENSSL_memset(&hint, 0, sizeof(hint));
+  hint.ai_family = AF_UNSPEC;
+  hint.ai_socktype = SOCK_STREAM;
+
+  ret = getaddrinfo(hostname, port_str, &hint, &result);
+  if (ret != 0) {
+    OPENSSL_PUT_ERROR(SYS, 0);
+#if defined(OPENSSL_WINDOWS)
+    ERR_add_error_data(1, gai_strerrorA(ret));
+#else
+    ERR_add_error_data(1, gai_strerror(ret));
+#endif
+    return 0;
+  }
+
+  ret = 0;
+
+  for (cur = result; cur; cur = cur->ai_next) {
+    if ((size_t) cur->ai_addrlen > sizeof(struct sockaddr_storage)) {
+      continue;
+    }
+    OPENSSL_memset(out_addr, 0, sizeof(struct sockaddr_storage));
+    OPENSSL_memcpy(out_addr, cur->ai_addr, cur->ai_addrlen);
+    *out_addr_length = cur->ai_addrlen;
+
+    *out_sock = socket(cur->ai_family, cur->ai_socktype, cur->ai_protocol);
+    if (*out_sock < 0) {
+      OPENSSL_PUT_SYSTEM_ERROR();
+      goto out;
+    }
+
+    ret = 1;
+    break;
+  }
+
+out:
+  freeaddrinfo(result);
+  return ret;
+}
+
+int bio_socket_nbio(int sock, int on) {
+#if defined(OPENSSL_WINDOWS)
+  u_long arg = on;
+
+  return 0 == ioctlsocket(sock, FIONBIO, &arg);
+#else
+  int flags = fcntl(sock, F_GETFL, 0);
+  if (flags < 0) {
+    return 0;
+  }
+  if (!on) {
+    flags &= ~O_NONBLOCK;
+  } else {
+    flags |= O_NONBLOCK;
+  }
+  return fcntl(sock, F_SETFL, flags) == 0;
+#endif
+}
+
+void bio_clear_socket_error() {}
+
+int bio_socket_finish_connect(int sock) {
+  // A blocked connect signals whether it is ready based on whether it is
+  // writable. (SO_ERROR is not filled in before it is writable.)
+#if defined(OPENSSL_WINDOWS)
+  fd_set write_set, except_set;
+  FD_ZERO(&write_set);
+  FD_SET(static_cast<SOCKET>(sock), &write_set);
+  FD_ZERO(&except_set);
+  FD_SET(static_cast<SOCKET>(sock), &except_set);
+  timeval timeout = {0, 0};
+  if (select(0 /* unused on Windows */, /*readfds=*/nullptr, &write_set,
+             &except_set, &timeout) == SOCKET_ERROR) {
+    return 0;
+  }
+  if (!FD_ISSET(sock, &write_set) && !FD_ISSET(sock, &except_set)) {
+    // The connect has not completed. Set the error that |connect| would return.
+    WSASetLastError(WSAEWOULDBLOCK);
+    return 0;
+  }
+#else
+  pollfd pfd;
+  pfd.fd = sock;
+  // poll implicitly listens for POLLERR and POLLHUP.
+  pfd.events = POLLOUT;
+  pfd.revents = 0;
+  if (poll(&pfd, 1, /*timeout=*/0) < 0) {
+    return 0;
+  }
+  if (pfd.revents == 0) {
+    // The connect has not completed. Set the error that |connect| would return.
+    errno = EINPROGRESS;
+    return 0;
+  }
+#endif
+
+  // Check if the connection succeeded.
+  int error;
+  socklen_t error_size = sizeof(error);
+  if (getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *)&error, &error_size) < 0) {
+    return 0;
+  }
+  if (error != 0) {
+#if defined(OPENSSL_WINDOWS)
+    WSASetLastError(error);
+#else
+    errno = error;
+#endif
+    return 0;
+  }
+  return 1;
+}
+
+int bio_socket_should_retry(int return_value) {
+#if defined(OPENSSL_WINDOWS)
+  return return_value == -1 && WSAGetLastError() == WSAEWOULDBLOCK;
+#else
+  // On POSIX platforms, sockets and fds are the same.
+  return bio_errno_should_retry(return_value);
+#endif
+}
+
+BSSL_NAMESPACE_END
+
+#endif  // OPENSSL_NO_SOCK

package/runtime/third_party/boringssl/crypto/blake2/blake2.cc

@@ -0,0 +1,173 @@
+// Copyright 2021 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/blake2.h>
+
+#include <assert.h>
+
+#include <iterator>
+
+#include "../internal.h"
+
+using namespace bssl;
+
+// https://tools.ietf.org/html/rfc7693#section-2.6
+static const uint64_t kIV[8] = {
+    UINT64_C(0x6a09e667f3bcc908), UINT64_C(0xbb67ae8584caa73b),
+    UINT64_C(0x3c6ef372fe94f82b), UINT64_C(0xa54ff53a5f1d36f1),
+    UINT64_C(0x510e527fade682d1), UINT64_C(0x9b05688c2b3e6c1f),
+    UINT64_C(0x1f83d9abfb41bd6b), UINT64_C(0x5be0cd19137e2179),
+};
+
+// https://tools.ietf.org/html/rfc7693#section-2.7
+static const uint8_t kSigma[10 * 16] = {
+    // clang-format off
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+    // clang-format on
+};
+
+// https://tools.ietf.org/html/rfc7693#section-3.1
+static void blake2b_mix(uint64_t v[16], int a, int b, int c, int d, uint64_t x,
+                        uint64_t y) {
+  v[a] = v[a] + v[b] + x;
+  v[d] = CRYPTO_rotr_u64(v[d] ^ v[a], 32);
+  v[c] = v[c] + v[d];
+  v[b] = CRYPTO_rotr_u64(v[b] ^ v[c], 24);
+  v[a] = v[a] + v[b] + y;
+  v[d] = CRYPTO_rotr_u64(v[d] ^ v[a], 16);
+  v[c] = v[c] + v[d];
+  v[b] = CRYPTO_rotr_u64(v[b] ^ v[c], 63);
+}
+
+static uint64_t blake2b_load(const uint8_t block[BLAKE2B_CBLOCK], size_t i) {
+  return CRYPTO_load_u64_le(block + 8 * i);
+}
+
+static void blake2b_transform(BLAKE2B_CTX *b2b,
+                              const uint8_t block[BLAKE2B_CBLOCK],
+                              size_t num_bytes, int is_final_block) {
+  // https://tools.ietf.org/html/rfc7693#section-3.2
+  uint64_t v[16];
+  static_assert(sizeof(v) == sizeof(b2b->h) + sizeof(kIV));
+  OPENSSL_memcpy(v, b2b->h, sizeof(b2b->h));
+  OPENSSL_memcpy(&v[8], kIV, sizeof(kIV));
+
+  b2b->t_low += num_bytes;
+  if (b2b->t_low < num_bytes) {
+    b2b->t_high++;
+  }
+  v[12] ^= b2b->t_low;
+  v[13] ^= b2b->t_high;
+
+  if (is_final_block) {
+    v[14] = ~v[14];
+  }
+
+  for (int round = 0; round < 12; round++) {
+    const uint8_t *const s = &kSigma[16 * (round % 10)];
+    blake2b_mix(v, 0, 4, 8, 12, blake2b_load(block, s[0]),
+                blake2b_load(block, s[1]));
+    blake2b_mix(v, 1, 5, 9, 13, blake2b_load(block, s[2]),
+                blake2b_load(block, s[3]));
+    blake2b_mix(v, 2, 6, 10, 14, blake2b_load(block, s[4]),
+                blake2b_load(block, s[5]));
+    blake2b_mix(v, 3, 7, 11, 15, blake2b_load(block, s[6]),
+                blake2b_load(block, s[7]));
+    blake2b_mix(v, 0, 5, 10, 15, blake2b_load(block, s[8]),
+                blake2b_load(block, s[9]));
+    blake2b_mix(v, 1, 6, 11, 12, blake2b_load(block, s[10]),
+                blake2b_load(block, s[11]));
+    blake2b_mix(v, 2, 7, 8, 13, blake2b_load(block, s[12]),
+                blake2b_load(block, s[13]));
+    blake2b_mix(v, 3, 4, 9, 14, blake2b_load(block, s[14]),
+                blake2b_load(block, s[15]));
+  }
+
+  for (size_t i = 0; i < std::size(b2b->h); i++) {
+    b2b->h[i] ^= v[i];
+    b2b->h[i] ^= v[i + 8];
+  }
+}
+
+void BLAKE2B256_Init(BLAKE2B_CTX *b2b) {
+  OPENSSL_memset(b2b, 0, sizeof(BLAKE2B_CTX));
+
+  static_assert(sizeof(kIV) == sizeof(b2b->h));
+  OPENSSL_memcpy(&b2b->h, kIV, sizeof(kIV));
+
+  // https://tools.ietf.org/html/rfc7693#section-2.5
+  b2b->h[0] ^= 0x01010000 | BLAKE2B256_DIGEST_LENGTH;
+}
+
+void BLAKE2B256_Update(BLAKE2B_CTX *b2b, const void *in_data, size_t len) {
+  if (len == 0) {
+    // Work around a C language bug. See https://crbug.com/1019588.
+    return;
+  }
+
+  const uint8_t *data = reinterpret_cast<const uint8_t *>(in_data);
+  size_t todo = sizeof(b2b->block) - b2b->block_used;
+  if (todo > len) {
+    todo = len;
+  }
+  OPENSSL_memcpy(&b2b->block[b2b->block_used], data, todo);
+  b2b->block_used += todo;
+  data += todo;
+  len -= todo;
+
+  if (!len) {
+    return;
+  }
+
+  // More input remains therefore we must have filled `b2b->block`.
+  assert(b2b->block_used == BLAKE2B_CBLOCK);
+  blake2b_transform(b2b, b2b->block, BLAKE2B_CBLOCK,
+                    /*is_final_block=*/0);
+  b2b->block_used = 0;
+
+  while (len > BLAKE2B_CBLOCK) {
+    blake2b_transform(b2b, data, BLAKE2B_CBLOCK, /*is_final_block=*/0);
+    data += BLAKE2B_CBLOCK;
+    len -= BLAKE2B_CBLOCK;
+  }
+
+  OPENSSL_memcpy(b2b->block, data, len);
+  b2b->block_used = len;
+}
+
+void BLAKE2B256_Final(uint8_t out[BLAKE2B256_DIGEST_LENGTH], BLAKE2B_CTX *b2b) {
+  OPENSSL_memset(&b2b->block[b2b->block_used], 0,
+                 sizeof(b2b->block) - b2b->block_used);
+  blake2b_transform(b2b, b2b->block, b2b->block_used,
+                    /*is_final_block=*/1);
+  static_assert(BLAKE2B256_DIGEST_LENGTH <= sizeof(b2b->h));
+  memcpy(out, b2b->h, BLAKE2B256_DIGEST_LENGTH);
+}
+
+void BLAKE2B256(const uint8_t *data, size_t len,
+                uint8_t out[BLAKE2B256_DIGEST_LENGTH]) {
+  BLAKE2B_CTX ctx;
+  BLAKE2B256_Init(&ctx);
+  BLAKE2B256_Update(&ctx, data, len);
+  BLAKE2B256_Final(out, &ctx);
+}

package/runtime/third_party/boringssl/crypto/bn/bn_asn1.cc

@@ -0,0 +1,57 @@
+// Copyright 2015 The BoringSSL Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <openssl/bn.h>
+
+#include <openssl/bytestring.h>
+#include <openssl/err.h>
+
+
+int BN_parse_asn1_unsigned(CBS *cbs, BIGNUM *ret) {
+  CBS child;
+  int is_negative;
+  if (!CBS_get_asn1(cbs, &child, CBS_ASN1_INTEGER) ||
+      !CBS_is_valid_asn1_integer(&child, &is_negative)) {
+    OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
+    return 0;
+  }
+
+  if (is_negative) {
+    OPENSSL_PUT_ERROR(BN, BN_R_NEGATIVE_NUMBER);
+    return 0;
+  }
+
+  return BN_bin2bn(CBS_data(&child), CBS_len(&child), ret) != nullptr;
+}
+
+int BN_marshal_asn1(CBB *cbb, const BIGNUM *bn) {
+  // Negative numbers are unsupported.
+  if (BN_is_negative(bn)) {
+    OPENSSL_PUT_ERROR(BN, BN_R_NEGATIVE_NUMBER);
+    return 0;
+  }
+
+  CBB child;
+  if (!CBB_add_asn1(cbb, &child, CBS_ASN1_INTEGER) ||
+      // The number must be padded with a leading zero if the high bit would
+      // otherwise be set or if `bn` is zero.
+      (BN_num_bits(bn) % 8 == 0 && !CBB_add_u8(&child, 0x00)) ||
+      !BN_bn2cbb_padded(&child, BN_num_bytes(bn), bn) ||
+      !CBB_flush(cbb)) {
+    OPENSSL_PUT_ERROR(BN, BN_R_ENCODE_ERROR);
+    return 0;
+  }
+
+  return 1;
+}