react-native-windows 0.84.0 → 0.85.0-preview.2

package/external/folly/folly/portability/PThread.h

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ *
+ *     http://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.
+ */
+
+#pragma once
+
+#include <folly/portability/Config.h>
+
+#if !defined(_WIN32)
+
+#include <pthread.h>
+
+#if defined(__FreeBSD__)
+#include <sys/thr.h> // @manual
+#endif
+
+#elif !FOLLY_HAVE_PTHREAD
+
+#include <cstdint>
+#include <memory>
+
+#include <folly/portability/Sched.h>
+#include <folly/portability/Time.h>
+#include <folly/portability/Windows.h>
+
+#include <folly/Portability.h>
+
+#define PTHREAD_CREATE_JOINABLE 0
+#define PTHREAD_CREATE_DETACHED 1
+
+#define PTHREAD_MUTEX_NORMAL 0
+#define PTHREAD_MUTEX_RECURSIVE 1
+#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
+
+#define _POSIX_TIMEOUTS 200112L
+
+namespace folly {
+namespace portability {
+namespace pthread {
+struct pthread_attr_t {
+  size_t stackSize;
+  bool detached;
+};
+
+int pthread_attr_init(pthread_attr_t* attr);
+int pthread_attr_setdetachstate(pthread_attr_t* attr, int state);
+int pthread_attr_setstacksize(pthread_attr_t* attr, size_t kb);
+
+namespace pthread_detail {
+struct pthread_t {
+  HANDLE handle{INVALID_HANDLE_VALUE};
+  DWORD threadID{0};
+  bool detached{false};
+
+  ~pthread_t() noexcept;
+};
+} // namespace pthread_detail
+using pthread_t = std::shared_ptr<pthread_detail::pthread_t>;
+
+int pthread_equal(pthread_t threadA, pthread_t threadB);
+int pthread_create(
+    pthread_t* thread,
+    const pthread_attr_t* attr,
+    void* (*start_routine)(void*),
+    void* arg);
+pthread_t pthread_self();
+int pthread_join(pthread_t thread, void** exitCode);
+
+HANDLE pthread_getw32threadhandle_np(pthread_t thread);
+DWORD pthread_getw32threadid_np(pthread_t thread);
+
+int pthread_setschedparam(
+    pthread_t thread, int policy, const sched_param* param);
+
+struct pthread_mutexattr_t {
+  int type;
+};
+int pthread_mutexattr_init(pthread_mutexattr_t* attr);
+int pthread_mutexattr_destroy(pthread_mutexattr_t* attr);
+int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int type);
+
+using pthread_mutex_t = struct pthread_mutex_t_*;
+int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attr);
+int pthread_mutex_destroy(pthread_mutex_t* mutex);
+int pthread_mutex_lock(pthread_mutex_t* mutex);
+int pthread_mutex_trylock(pthread_mutex_t* mutex);
+int pthread_mutex_unlock(pthread_mutex_t* mutex);
+int pthread_mutex_timedlock(
+    pthread_mutex_t* mutex, const timespec* abs_timeout);
+
+using pthread_rwlock_t = struct pthread_rwlock_t_*;
+// Technically the second argument here is supposed to be a
+// const pthread_rwlockattr_t* but we don support it, so we
+// simply don't define pthread_rwlockattr_t at all to cause
+// a build-break if anyone tries to use it.
+int pthread_rwlock_init(pthread_rwlock_t* rwlock, const void* attr);
+int pthread_rwlock_destroy(pthread_rwlock_t* rwlock);
+int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);
+int pthread_rwlock_tryrdlock(pthread_rwlock_t* rwlock);
+int pthread_rwlock_timedrdlock(
+    pthread_rwlock_t* rwlock, const timespec* abs_timeout);
+int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
+int pthread_rwlock_trywrlock(pthread_rwlock_t* rwlock);
+int pthread_rwlock_timedwrlock(
+    pthread_rwlock_t* rwlock, const timespec* abs_timeout);
+int pthread_rwlock_unlock(pthread_rwlock_t* rwlock);
+
+using pthread_cond_t = struct pthread_cond_t_*;
+// Once again, technically the second argument should be a
+// pthread_condattr_t, but we don't implement it, so void*
+// it is.
+int pthread_cond_init(pthread_cond_t* cond, const void* attr);
+int pthread_cond_destroy(pthread_cond_t* cond);
+int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex);
+int pthread_cond_timedwait(
+    pthread_cond_t* cond, pthread_mutex_t* mutex, const timespec* abstime);
+int pthread_cond_signal(pthread_cond_t* cond);
+int pthread_cond_broadcast(pthread_cond_t* cond);
+
+// In reality, this is boost::thread_specific_ptr*, but we're attempting
+// to avoid introducing boost into a portability header.
+using pthread_key_t = void*;
+
+int pthread_key_create(pthread_key_t* key, void (*destructor)(void*));
+int pthread_key_delete(pthread_key_t key);
+void* pthread_getspecific(pthread_key_t key);
+int pthread_setspecific(pthread_key_t key, const void* value);
+} // namespace pthread
+} // namespace portability
+} // namespace folly
+
+FOLLY_PUSH_WARNING
+FOLLY_CLANG_DISABLE_WARNING("-Wheader-hygiene")
+/* using override */ using namespace folly::portability::pthread;
+FOLLY_POP_WARNING
+#endif

package/external/folly/folly/portability/README.md

@@ -0,0 +1,21 @@
+Warning
+=======
+
+These portability headers are **internal implementation details**.
+
+They are intended to ensure that Folly can build on a variety of platforms.
+
+They are not intended to help you build your programs on these platforms.
+
+They are, and will remain, undocumented. They are, and will remain, subject to
+rapid, immediate, and drastic changes - including full rewrites and merciless
+deletions - without notice.
+
+Note that before adding a new file to this directory you should determine
+whether the API you are adding is a portability header or just a platform
+dependent implementation detail. Only portability headers belong in this
+directory. A portability header is defined as a header that provides the exact
+API of some platform or configuration that is not available on all platforms.
+If the API being added does not already exist on at least one of the platforms
+Folly supports, then it is an implementation detail, and does not belong in
+this directory.

package/external/folly/folly/portability/Sched.cpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ *
+ *     http://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 <folly/portability/Sched.h>
+
+#ifdef _WIN32
+#include <thread>
+
+namespace folly {
+namespace portability {
+namespace sched {
+int sched_yield() {
+  std::this_thread::yield();
+  return 0;
+}
+
+// There is only 1 scheduling policy on Windows
+int sched_get_priority_min(int policy) {
+  return -15;
+}
+
+int sched_get_priority_max(int policy) {
+  return 15;
+}
+} // namespace sched
+} // namespace portability
+} // namespace folly
+#endif

package/external/folly/folly/portability/Sched.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ *
+ *     http://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.
+ */
+
+#pragma once
+
+#ifndef _WIN32
+#include <sched.h>
+#else
+#define SCHED_OTHER 0
+#define SCHED_FIFO 1
+#define SCHED_RR 2
+
+#include <folly/Portability.h>
+
+namespace folly {
+namespace portability {
+namespace sched {
+struct sched_param {
+  int sched_priority;
+};
+int sched_yield();
+int sched_get_priority_min(int policy);
+int sched_get_priority_max(int policy);
+} // namespace sched
+} // namespace portability
+} // namespace folly
+
+FOLLY_PUSH_WARNING
+FOLLY_CLANG_DISABLE_WARNING("-Wheader-hygiene")
+/* using override */ using namespace folly::portability::sched;
+FOLLY_POP_WARNING
+#endif

package/external/folly/folly/portability/Sockets.cpp

@@ -0,0 +1,245 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ *
+ *     http://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 <folly/portability/Sockets.h>
+
+#ifdef _MSC_VER
+
+#include <errno.h>
+#include <fcntl.h>
+
+#include <MSWSock.h> // @manual
+
+#include <folly/ScopeGuard.h>
+#include <folly/net/NetworkSocket.h>
+#include <folly/net/detail/SocketFileDescriptorMap.h>
+
+namespace folly {
+namespace portability {
+namespace sockets {
+
+namespace {
+int network_socket_to_fd(NetworkSocket sock) {
+  return socket_to_fd(sock.data);
+}
+
+NetworkSocket fd_to_network_socket(int fd) {
+  return NetworkSocket(fd_to_socket(fd));
+}
+} // namespace
+
+bool is_fh_socket(int fh) {
+  SOCKET h = fd_to_socket(fh);
+  constexpr long kDummyEvents = 0xABCDEF12;
+  WSANETWORKEVENTS e;
+  e.lNetworkEvents = kDummyEvents;
+  WSAEnumNetworkEvents(h, nullptr, &e);
+  return e.lNetworkEvents != kDummyEvents;
+}
+
+SOCKET fd_to_socket(int fd) {
+  return netops::detail::SocketFileDescriptorMap::fdToSocket(fd);
+}
+
+int socket_to_fd(SOCKET s) {
+  return netops::detail::SocketFileDescriptorMap::socketToFd(s);
+}
+
+template <class R, class F, class... Args>
+static R wrapSocketFunction(F f, int s, Args... args) {
+  NetworkSocket h = fd_to_network_socket(s);
+  return f(h, args...);
+}
+
+int accept(int s, struct sockaddr* addr, socklen_t* addrlen) {
+  return network_socket_to_fd(
+      wrapSocketFunction<NetworkSocket>(netops::accept, s, addr, addrlen));
+}
+
+int bind(int s, const struct sockaddr* name, socklen_t namelen) {
+  return wrapSocketFunction<int>(netops::bind, s, name, namelen);
+}
+
+int connect(int s, const struct sockaddr* name, socklen_t namelen) {
+  return wrapSocketFunction<int>(netops::connect, s, name, namelen);
+}
+
+int getpeername(int s, struct sockaddr* name, socklen_t* namelen) {
+  return wrapSocketFunction<int>(netops::getpeername, s, name, namelen);
+}
+
+int getsockname(int s, struct sockaddr* name, socklen_t* namelen) {
+  return wrapSocketFunction<int>(netops::getsockname, s, name, namelen);
+}
+
+int getsockopt(int s, int level, int optname, char* optval, socklen_t* optlen) {
+  return getsockopt(s, level, optname, (void*)optval, optlen);
+}
+
+int getsockopt(int s, int level, int optname, void* optval, socklen_t* optlen) {
+  return wrapSocketFunction<int>(
+      netops::getsockopt, s, level, optname, optval, optlen);
+}
+
+int inet_aton(const char* cp, struct in_addr* inp) {
+  return netops::inet_aton(cp, inp);
+}
+
+const char* inet_ntop(int af, const void* src, char* dst, socklen_t size) {
+  return ::inet_ntop(af, (char*)src, dst, size_t(size));
+}
+
+int listen(int s, int backlog) {
+  return wrapSocketFunction<int>(netops::listen, s, backlog);
+}
+
+int poll(struct pollfd fds[], nfds_t nfds, int timeout) {
+  // NetOps already has the checks to ensure this is safe.
+  netops::PollDescriptor* desc =
+      reinterpret_cast<netops::PollDescriptor*>(reinterpret_cast<void*>(fds));
+  for (nfds_t i = 0; i < nfds; ++i) {
+    desc[i].fd = fd_to_network_socket((int)desc[i].fd.data);
+  }
+  return netops::poll(desc, nfds, timeout);
+}
+
+ssize_t recv(int s, void* buf, size_t len, int flags) {
+  return wrapSocketFunction<ssize_t>(netops::recv, s, buf, len, flags);
+}
+
+ssize_t recv(int s, char* buf, int len, int flags) {
+  return recv(s, (void*)buf, (size_t)len, flags);
+}
+
+ssize_t recv(int s, void* buf, int len, int flags) {
+  return recv(s, (void*)buf, (size_t)len, flags);
+}
+
+ssize_t recvfrom(
+    int s,
+    void* buf,
+    size_t len,
+    int flags,
+    struct sockaddr* from,
+    socklen_t* fromlen) {
+  return wrapSocketFunction<ssize_t>(
+      netops::recvfrom, s, buf, len, flags, from, fromlen);
+}
+
+ssize_t recvfrom(
+    int s,
+    char* buf,
+    int len,
+    int flags,
+    struct sockaddr* from,
+    socklen_t* fromlen) {
+  return recvfrom(s, (void*)buf, (size_t)len, flags, from, fromlen);
+}
+
+ssize_t recvfrom(
+    int s,
+    void* buf,
+    int len,
+    int flags,
+    struct sockaddr* from,
+    socklen_t* fromlen) {
+  return recvfrom(s, (void*)buf, (size_t)len, flags, from, fromlen);
+}
+
+ssize_t recvmsg(int s, struct msghdr* message, int flags) {
+  return wrapSocketFunction<ssize_t>(netops::recvmsg, s, message, flags);
+}
+
+ssize_t send(int s, const void* buf, size_t len, int flags) {
+  return wrapSocketFunction<ssize_t>(netops::send, s, buf, len, flags);
+}
+
+ssize_t send(int s, const char* buf, int len, int flags) {
+  return send(s, (const void*)buf, (size_t)len, flags);
+}
+
+ssize_t send(int s, const void* buf, int len, int flags) {
+  return send(s, (const void*)buf, (size_t)len, flags);
+}
+
+ssize_t sendmsg(int s, const struct msghdr* message, int flags) {
+  return wrapSocketFunction<ssize_t>(netops::sendmsg, s, message, flags);
+}
+
+ssize_t sendto(
+    int s,
+    const void* buf,
+    size_t len,
+    int flags,
+    const sockaddr* to,
+    socklen_t tolen) {
+  return wrapSocketFunction<ssize_t>(
+      netops::sendto, s, buf, len, flags, to, tolen);
+}
+
+ssize_t sendto(
+    int s,
+    const char* buf,
+    int len,
+    int flags,
+    const sockaddr* to,
+    socklen_t tolen) {
+  return sendto(s, (const void*)buf, (size_t)len, flags, to, tolen);
+}
+
+ssize_t sendto(
+    int s,
+    const void* buf,
+    int len,
+    int flags,
+    const sockaddr* to,
+    socklen_t tolen) {
+  return sendto(s, buf, (size_t)len, flags, to, tolen);
+}
+
+int setsockopt(
+    int s, int level, int optname, const void* optval, socklen_t optlen) {
+  return wrapSocketFunction<int>(
+      netops::setsockopt, s, level, optname, optval, optlen);
+}
+
+int setsockopt(
+    int s, int level, int optname, const char* optval, socklen_t optlen) {
+  return setsockopt(s, level, optname, (const void*)optval, optlen);
+}
+
+int shutdown(int s, int how) {
+  return wrapSocketFunction<int>(netops::shutdown, s, how);
+}
+
+int socket(int af, int type, int protocol) {
+  return network_socket_to_fd(netops::socket(af, type, protocol));
+}
+
+int socketpair(int domain, int type, int protocol, int sv[2]) {
+  NetworkSocket pair[2];
+  auto r = netops::socketpair(domain, type, protocol, pair);
+  if (r == -1) {
+    return r;
+  }
+  sv[0] = network_socket_to_fd(pair[0]);
+  sv[1] = network_socket_to_fd(pair[1]);
+  return 0;
+}
+} // namespace sockets
+} // namespace portability
+} // namespace folly
+#endif

package/external/folly/folly/portability/Sockets.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ *
+ *     http://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.
+ */
+
+#pragma once
+
+#include <folly/net/NetOps.h>
+
+#include <folly/Portability.h>
+
+namespace folly {
+namespace portability {
+namespace sockets {
+
+#ifdef _WIN32
+
+// Some Windows specific helper functions.
+bool is_fh_socket(int fh);
+SOCKET fd_to_socket(int fd);
+int socket_to_fd(SOCKET s);
+
+// These aren't additional overloads, but rather other functions that
+// are referenced that we need to wrap, or, in the case of inet_aton,
+// implement.
+int accept(int s, struct sockaddr* addr, socklen_t* addrlen);
+int inet_aton(const char* cp, struct in_addr* inp);
+int socketpair(int domain, int type, int protocol, int sv[2]);
+
+// Unless you have a case where you would normally have
+// to reference the function as being explicitly in the
+// global scope, then you shouldn't be calling these directly.
+int bind(int s, const struct sockaddr* name, socklen_t namelen);
+int connect(int s, const struct sockaddr* name, socklen_t namelen);
+int getpeername(int s, struct sockaddr* name, socklen_t* namelen);
+int getsockname(int s, struct sockaddr* name, socklen_t* namelen);
+int getsockopt(int s, int level, int optname, void* optval, socklen_t* optlen);
+const char* inet_ntop(int af, const void* src, char* dst, socklen_t size);
+int listen(int s, int backlog);
+int poll(struct pollfd fds[], nfds_t nfds, int timeout);
+ssize_t recv(int s, void* buf, size_t len, int flags);
+ssize_t recvfrom(
+    int s,
+    void* buf,
+    size_t len,
+    int flags,
+    struct sockaddr* from,
+    socklen_t* fromlen);
+ssize_t send(int s, const void* buf, size_t len, int flags);
+ssize_t sendto(
+    int s,
+    const void* buf,
+    size_t len,
+    int flags,
+    const sockaddr* to,
+    socklen_t tolen);
+ssize_t sendmsg(int socket, const struct msghdr* message, int flags);
+int setsockopt(
+    int s, int level, int optname, const void* optval, socklen_t optlen);
+int shutdown(int s, int how);
+
+// This is the only function that _must_ be referenced via the namespace
+// because there is no difference in parameter types to overload
+// on.
+int socket(int af, int type, int protocol);
+
+// Windows needs a few extra overloads of some of the functions in order to
+// resolve to our portability functions rather than the SOCKET accepting
+// ones.
+int getsockopt(int s, int level, int optname, char* optval, socklen_t* optlen);
+ssize_t recv(int s, char* buf, int len, int flags);
+ssize_t recv(int s, void* buf, int len, int flags);
+ssize_t recvfrom(
+    int s,
+    char* buf,
+    int len,
+    int flags,
+    struct sockaddr* from,
+    socklen_t* fromlen);
+ssize_t recvfrom(
+    int s,
+    void* buf,
+    int len,
+    int flags,
+    struct sockaddr* from,
+    socklen_t* fromlen);
+ssize_t recvmsg(int s, struct msghdr* message, int fl);
+ssize_t send(int s, const char* buf, int len, int flags);
+ssize_t send(int s, const void* buf, int len, int flags);
+ssize_t sendto(
+    int s,
+    const char* buf,
+    int len,
+    int flags,
+    const sockaddr* to,
+    socklen_t tolen);
+ssize_t sendto(
+    int s,
+    const void* buf,
+    int len,
+    int flags,
+    const sockaddr* to,
+    socklen_t tolen);
+int setsockopt(
+    int s, int level, int optname, const char* optval, socklen_t optlen);
+
+#elif defined(__EMSCRIPTEN__)
+
+// None of these are implemented or referenced right now.
+
+#else
+
+using ::accept;
+using ::bind;
+using ::connect;
+using ::getpeername;
+using ::getsockname;
+using ::getsockopt;
+using ::inet_ntop;
+using ::listen;
+using ::poll;
+using ::recv;
+using ::recvfrom;
+using ::send;
+using ::sendmsg;
+using ::sendto;
+using ::setsockopt;
+using ::shutdown;
+using ::socket;
+
+#endif
+
+} // namespace sockets
+} // namespace portability
+} // namespace folly
+
+#ifdef _WIN32
+// Add our helpers to the overload set.
+FOLLY_PUSH_WARNING
+FOLLY_CLANG_DISABLE_WARNING("-Wheader-hygiene")
+/* using override */
+using namespace folly::portability::sockets;
+FOLLY_POP_WARNING
+#endif

package/external/folly/folly/portability/SourceLocation.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ *
+ *     http://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.
+ */
+
+#pragma once
+
+#include <version>
+
+#include <fmt/format.h>
+
+#if __has_include(<source_location>) && defined __cpp_lib_source_location
+#include <source_location> // @manual
+namespace folly {
+using source_location = ::std::source_location;
+#elif __has_include(<experimental/source_location>)
+#include <experimental/source_location>
+namespace folly {
+using source_location = ::std::experimental::source_location;
+#else
+namespace folly {
+struct source_location {
+  static source_location current() noexcept { return source_location{}; }
+  const char* function_name() const noexcept { return ""; }
+  const char* file_name() const noexcept { return ""; }
+  std::uint_least32_t line() const noexcept { return 0; }
+  std::uint_least32_t column() const noexcept { return 0; }
+};
+#endif
+
+inline auto sourceLocationToString(const source_location& location) {
+  return fmt::format(
+      "{}:{} [{}]",
+      location.file_name(),
+      location.line(),
+      location.function_name());
+}
+}