@ohos-ports/confluentinc-kafka-javascript 1.10.0-beta.1

package/deps/librdkafka/src/rdvarint.c

@@ -0,0 +1,134 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2016-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include "rdvarint.h"
+#include "rdunittest.h"
+
+
+static int do_test_rd_uvarint_enc_i64(const char *file,
+                                      int line,
+                                      int64_t num,
+                                      const char *exp,
+                                      size_t exp_size) {
+        char buf[16] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+        size_t sz    = rd_uvarint_enc_i64(buf, sizeof(buf), num);
+        size_t r;
+        int ir;
+        rd_buf_t b;
+        rd_slice_t slice, bad_slice;
+        int64_t ret_num;
+
+        if (sz != exp_size || memcmp(buf, exp, exp_size))
+                RD_UT_FAIL("i64 encode of %" PRId64
+                           ": "
+                           "expected size %" PRIusz " (got %" PRIusz ")\n",
+                           num, exp_size, sz);
+
+        /* Verify with standard decoder */
+        r = rd_varint_dec_i64(buf, sz, &ret_num);
+        RD_UT_ASSERT(!RD_UVARINT_DEC_FAILED(r),
+                     "varint decode failed: %" PRIusz, r);
+        RD_UT_ASSERT(ret_num == num,
+                     "varint decode returned wrong number: "
+                     "%" PRId64 " != %" PRId64,
+                     ret_num, num);
+
+        /* Verify with slice decoder */
+        rd_buf_init(&b, 1, 0);
+        rd_buf_push(&b, buf, sizeof(buf), NULL); /* including trailing 0xff
+                                                  * garbage which should be
+                                                  * ignored by decoder */
+        rd_slice_init_full(&slice, &b);
+
+        /* Should fail for incomplete reads */
+        ir = rd_slice_narrow_copy(&slice, &bad_slice, sz - 1);
+        RD_UT_ASSERT(ir, "narrow_copy failed");
+        ret_num = -1;
+        r       = rd_slice_read_varint(&bad_slice, &ret_num);
+        RD_UT_ASSERT(RD_UVARINT_DEC_FAILED(r),
+                     "varint decode failed should have failed, "
+                     "returned %" PRIusz,
+                     r);
+        r = rd_slice_offset(&bad_slice);
+        RD_UT_ASSERT(r == 0,
+                     "expected slice position to not change, but got %" PRIusz,
+                     r);
+
+        /* Verify proper slice */
+        ret_num = -1;
+        r       = rd_slice_read_varint(&slice, &ret_num);
+        RD_UT_ASSERT(!RD_UVARINT_DEC_FAILED(r),
+                     "varint decode failed: %" PRIusz, r);
+        RD_UT_ASSERT(ret_num == num,
+                     "varint decode returned wrong number: "
+                     "%" PRId64 " != %" PRId64,
+                     ret_num, num);
+        RD_UT_ASSERT(r == sz,
+                     "expected varint decoder to read %" PRIusz
+                     " bytes, "
+                     "not %" PRIusz,
+                     sz, r);
+        r = rd_slice_offset(&slice);
+        RD_UT_ASSERT(r == sz,
+                     "expected slice position to change to %" PRIusz
+                     ", but got %" PRIusz,
+                     sz, r);
+
+
+        rd_buf_destroy(&b);
+
+        RD_UT_PASS();
+}
+
+
+int unittest_rdvarint(void) {
+        int fails = 0;
+
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, 0,
+                                            (const char[]) {0}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, 1,
+                                            (const char[]) {0x2}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, -1,
+                                            (const char[]) {0x1}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, 23,
+                                            (const char[]) {0x2e}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, -23,
+                                            (const char[]) {0x2d}, 1);
+        fails += do_test_rd_uvarint_enc_i64(__FILE__, __LINE__, 253,
+                                            (const char[]) {0xfa, 3}, 2);
+        fails += do_test_rd_uvarint_enc_i64(
+            __FILE__, __LINE__, 1234567890101112,
+            (const char[]) {0xf0, 0x8d, 0xd3, 0xc8, 0xa7, 0xb5, 0xb1, 0x04}, 8);
+        fails += do_test_rd_uvarint_enc_i64(
+            __FILE__, __LINE__, -1234567890101112,
+            (const char[]) {0xef, 0x8d, 0xd3, 0xc8, 0xa7, 0xb5, 0xb1, 0x04}, 8);
+
+        return fails;
+}

package/deps/librdkafka/src/rdvarint.h

@@ -0,0 +1,165 @@
+/*
+ * librdkafka - The Apache Kafka C/C++ library
+ *
+ * Copyright (c) 2016-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef _RDVARINT_H
+#define _RDVARINT_H
+
+#include "rd.h"
+#include "rdbuf.h"
+
+/**
+ * @name signed varint zig-zag encoder/decoder
+ * @{
+ *
+ */
+
+/**
+ * @brief unsigned-varint encodes unsigned integer \p num into buffer
+ *        at \p dst of size \p dstsize.
+ * @returns the number of bytes written to \p dst, or 0 if not enough space.
+ */
+
+static RD_INLINE RD_UNUSED size_t rd_uvarint_enc_u64(char *dst,
+                                                     size_t dstsize,
+                                                     uint64_t num) {
+        size_t of = 0;
+
+        do {
+                if (unlikely(of >= dstsize))
+                        return 0; /* Not enough space */
+
+                dst[of++] = (num & 0x7f) | (num > 0x7f ? 0x80 : 0);
+                num >>= 7;
+        } while (num);
+
+        return of;
+}
+
+/**
+ * @brief encodes a signed integer using zig-zag encoding.
+ * @sa rd_uvarint_enc_u64
+ */
+static RD_INLINE RD_UNUSED size_t rd_uvarint_enc_i64(char *dst,
+                                                     size_t dstsize,
+                                                     int64_t num) {
+        return rd_uvarint_enc_u64(dst, dstsize, (num << 1) ^ (num >> 63));
+}
+
+
+static RD_INLINE RD_UNUSED size_t rd_uvarint_enc_i32(char *dst,
+                                                     size_t dstsize,
+                                                     int32_t num) {
+        return rd_uvarint_enc_i64(dst, dstsize, num);
+}
+
+
+
+/**
+ * @brief Use on return value from rd_uvarint_dec() to check if
+ *        decoded varint fit the size_t.
+ *
+ * @returns 1 on overflow, else 0.
+ */
+#define RD_UVARINT_OVERFLOW(DEC_RETVAL) (DEC_RETVAL > SIZE_MAX)
+
+/**
+ * @returns 1 if there were not enough bytes to decode the varint, else 0.
+ */
+#define RD_UVARINT_UNDERFLOW(DEC_RETVAL) (DEC_RETVAL == 0)
+
+
+/**
+ * @param DEC_RETVAL the return value from \c rd_uvarint_dec()
+ * @returns 1 if varint decoding failed, else 0.
+ * @warning \p DEC_RETVAL will be evaluated twice.
+ */
+#define RD_UVARINT_DEC_FAILED(DEC_RETVAL)                                      \
+        (RD_UVARINT_UNDERFLOW(DEC_RETVAL) || RD_UVARINT_OVERFLOW(DEC_RETVAL))
+
+
+/**
+ * @brief Decodes the unsigned-varint in buffer \p src of size \p srcsize
+ *        and stores the decoded unsigned integer in \p nump.
+ *
+ * @remark Use RD_UVARINT_OVERFLOW(returnvalue) to check if the varint
+ *         could not fit \p nump, and RD_UVARINT_UNDERFLOW(returnvalue) to
+ *         check if there were not enough bytes available in \p src to
+ *         decode the full varint.
+ *
+ * @returns the number of bytes read from \p src.
+ */
+static RD_INLINE RD_UNUSED size_t rd_uvarint_dec(const char *src,
+                                                 size_t srcsize,
+                                                 uint64_t *nump) {
+        size_t of    = 0;
+        uint64_t num = 0;
+        int shift    = 0;
+
+        do {
+                if (unlikely(srcsize-- == 0))
+                        return 0; /* Underflow */
+                num |= (uint64_t)(src[(int)of] & 0x7f) << shift;
+                shift += 7;
+        } while (src[(int)of++] & 0x80);
+
+        *nump = num;
+        return of;
+}
+
+static RD_INLINE RD_UNUSED size_t rd_varint_dec_i64(const char *src,
+                                                    size_t srcsize,
+                                                    int64_t *nump) {
+        uint64_t n;
+        size_t r;
+
+        r = rd_uvarint_dec(src, srcsize, &n);
+        if (likely(!RD_UVARINT_DEC_FAILED(r)))
+                *nump = (int64_t)(n >> 1) ^ -(int64_t)(n & 1);
+
+        return r;
+}
+
+
+/**
+ * @returns the maximum encoded size for a type
+ */
+#define RD_UVARINT_ENC_SIZEOF(TYPE) (sizeof(TYPE) + 1 + (sizeof(TYPE) / 7))
+
+/**
+ * @returns the encoding size of the value 0
+ */
+#define RD_UVARINT_ENC_SIZE_0() ((size_t)1)
+
+
+int unittest_rdvarint(void);
+
+/**@}*/
+
+
+#endif /* _RDVARINT_H */

package/deps/librdkafka/src/rdwin32.h

@@ -0,0 +1,382 @@
+/*
+ * librdkafka - Apache Kafka C library
+ *
+ * Copyright (c) 2012-2022, Magnus Edenhill
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * Win32 (Visual Studio) support
+ */
+#ifndef _RDWIN32_H_
+#define _RDWIN32_H_
+
+#include <stdlib.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <time.h>
+#include <assert.h>
+
+#define WIN32_MEAN_AND_LEAN
+#include <winsock2.h> /* for sockets + struct timeval */
+#include <io.h>
+#include <fcntl.h>
+#include <windows.h>
+
+/**
+ * Types
+ */
+#ifndef _SSIZE_T_DEFINED
+#define _SSIZE_T_DEFINED
+typedef SSIZE_T ssize_t;
+#endif
+typedef int socklen_t;
+
+struct iovec {
+        void *iov_base;
+        size_t iov_len;
+};
+
+struct msghdr {
+        struct iovec *msg_iov;
+        int msg_iovlen;
+};
+
+
+/**
+ * Annotations, attributes, optimizers
+ */
+#ifndef likely
+#define likely(x) x
+#endif
+#ifndef unlikely
+#define unlikely(x) x
+#endif
+
+#define RD_UNUSED
+#define RD_INLINE __inline
+#define RD_WARN_UNUSED_RESULT
+#define RD_NORETURN       __declspec(noreturn)
+#define RD_IS_CONSTANT(p) (0)
+#ifdef _MSC_VER
+#define RD_TLS __declspec(thread)
+#elif defined(__MINGW32__)
+#define RD_TLS __thread
+#else
+#error Unknown Windows compiler, cannot set RD_TLS (thread-local-storage attribute)
+#endif
+
+
+/**
+ * Allocation
+ */
+#define rd_alloca(N) _alloca(N)
+
+
+/**
+ * Strings, formatting, printf, ..
+ */
+
+/* size_t and ssize_t format strings */
+#define PRIusz "Iu"
+#define PRIdsz "Id"
+
+#ifndef RD_FORMAT
+#define RD_FORMAT(...)
+#endif
+
+static RD_UNUSED RD_INLINE int
+rd_vsnprintf(char *str, size_t size, const char *format, va_list ap) {
+        int cnt = -1;
+
+        if (size != 0)
+                cnt = _vsnprintf_s(str, size, _TRUNCATE, format, ap);
+        if (cnt == -1)
+                cnt = _vscprintf(format, ap);
+
+        return cnt;
+}
+
+static RD_UNUSED RD_INLINE int
+rd_snprintf(char *str, size_t size, const char *format, ...) {
+        int cnt;
+        va_list ap;
+
+        va_start(ap, format);
+        cnt = rd_vsnprintf(str, size, format, ap);
+        va_end(ap);
+
+        return cnt;
+}
+
+
+#define rd_strcasecmp(A, B)     _stricmp(A, B)
+#define rd_strncasecmp(A, B, N) _strnicmp(A, B, N)
+/* There is a StrStrIA() but it requires extra linking, so use our own
+ * implementation instead. */
+#define rd_strcasestr(HAYSTACK, NEEDLE) _rd_strcasestr(HAYSTACK, NEEDLE)
+
+
+
+/**
+ * Errors
+ */
+
+/* MSVC:
+ * This is the correct way to set errno on Windows,
+ * but it is still pointless due to different errnos in
+ * in different runtimes:
+ * https://social.msdn.microsoft.com/Forums/vstudio/en-US/b4500c0d-1b69-40c7-9ef5-08da1025b5bf/setting-errno-from-within-a-dll?forum=vclanguage/
+ * errno is thus highly deprecated, and buggy, on Windows
+ * when using librdkafka as a dynamically loaded DLL. */
+#define rd_set_errno(err) _set_errno((err))
+
+static RD_INLINE RD_UNUSED const char *rd_strerror(int err) {
+        static RD_TLS char ret[128];
+
+        strerror_s(ret, sizeof(ret) - 1, err);
+        return ret;
+}
+
+/**
+ * @brief strerror() for Win32 API errors as returned by GetLastError() et.al.
+ */
+static RD_UNUSED char *
+rd_strerror_w32(DWORD errcode, char *dst, size_t dstsize) {
+        char *t;
+        FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM |
+                           FORMAT_MESSAGE_IGNORE_INSERTS,
+                       NULL, errcode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                       (LPSTR)dst, (DWORD)dstsize - 1, NULL);
+        /* Remove newlines */
+        while ((t = strchr(dst, (int)'\r')) || (t = strchr(dst, (int)'\n')))
+                *t = (char)'.';
+        return dst;
+}
+
+
+/**
+ * Atomics
+ */
+#ifndef __cplusplus
+#include "rdatomic.h"
+#endif
+
+
+/**
+ * Misc
+ */
+
+/**
+ * Microsecond sleep.
+ * 'retry': if true, retry if sleep is interrupted (because of signal)
+ */
+#define rd_usleep(usec, terminate) Sleep((usec) / 1000)
+
+
+/**
+ * @brief gettimeofday() for win32
+ */
+static RD_UNUSED int rd_gettimeofday(struct timeval *tv, struct timezone *tz) {
+        SYSTEMTIME st;
+        FILETIME ft;
+        ULARGE_INTEGER d;
+
+        GetSystemTime(&st);
+        SystemTimeToFileTime(&st, &ft);
+        d.HighPart  = ft.dwHighDateTime;
+        d.LowPart   = ft.dwLowDateTime;
+        tv->tv_sec  = (long)((d.QuadPart - 116444736000000000llu) / 10000000L);
+        tv->tv_usec = (long)(st.wMilliseconds * 1000);
+
+        return 0;
+}
+
+
+#define rd_assert(EXPR) assert(EXPR)
+
+
+static RD_INLINE RD_UNUSED const char *rd_getenv(const char *env,
+                                                 const char *def) {
+        static RD_TLS char tmp[512];
+        DWORD r;
+        r = GetEnvironmentVariableA(env, tmp, sizeof(tmp));
+        if (r == 0 || r > sizeof(tmp))
+                return def;
+        return tmp;
+}
+
+
+/**
+ * Empty struct initializer
+ */
+#define RD_ZERO_INIT                                                           \
+        { 0 }
+
+#ifndef __cplusplus
+/**
+ * Sockets, IO
+ */
+
+/** @brief Socket type */
+typedef SOCKET rd_socket_t;
+
+/** @brief Socket API error return value */
+#define RD_SOCKET_ERROR SOCKET_ERROR
+
+/** @brief Last socket error */
+#define rd_socket_errno WSAGetLastError()
+
+/** @brief String representation of socket error */
+static RD_UNUSED const char *rd_socket_strerror(int err) {
+        static RD_TLS char buf[256];
+        rd_strerror_w32(err, buf, sizeof(buf));
+        return buf;
+}
+
+/** @brief WSAPoll() struct type */
+typedef WSAPOLLFD rd_pollfd_t;
+
+/** @brief poll(2) */
+#define rd_socket_poll(POLLFD, FDCNT, TIMEOUT_MS)                              \
+        WSAPoll(POLLFD, FDCNT, TIMEOUT_MS)
+
+
+/**
+ * @brief Set socket to non-blocking
+ * @returns 0 on success or -1 on failure (see rd_kafka_rd_socket_errno)
+ */
+static RD_UNUSED int rd_fd_set_nonblocking(rd_socket_t fd) {
+        u_long on = 1;
+        if (ioctlsocket(fd, FIONBIO, &on) == SOCKET_ERROR)
+                return (int)WSAGetLastError();
+        return 0;
+}
+
+/**
+ * @brief Create non-blocking pipe
+ * @returns 0 on success or errno on failure
+ */
+static RD_UNUSED int rd_pipe_nonblocking(rd_socket_t *fds) {
+        /* On windows, the "pipe" will be a tcp connection.
+         * This is to allow WSAPoll to be used to poll pipe events */
+
+        SOCKET listen_s  = INVALID_SOCKET;
+        SOCKET accept_s  = INVALID_SOCKET;
+        SOCKET connect_s = INVALID_SOCKET;
+
+        struct sockaddr_in listen_addr;
+        struct sockaddr_in connect_addr;
+        socklen_t sock_len = 0;
+        int bufsz;
+
+        /* Create listen socket */
+        listen_s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        if (listen_s == INVALID_SOCKET)
+                goto err;
+
+        listen_addr.sin_family      = AF_INET;
+        listen_addr.sin_addr.s_addr = ntohl(INADDR_LOOPBACK);
+        listen_addr.sin_port        = 0;
+        if (bind(listen_s, (struct sockaddr *)&listen_addr,
+                 sizeof(listen_addr)) != 0)
+                goto err;
+
+        sock_len = sizeof(connect_addr);
+        if (getsockname(listen_s, (struct sockaddr *)&connect_addr,
+                        &sock_len) != 0)
+                goto err;
+
+        if (listen(listen_s, 1) != 0)
+                goto err;
+
+        /* Create connection socket */
+        connect_s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+        if (connect_s == INVALID_SOCKET)
+                goto err;
+
+        if (connect(connect_s, (struct sockaddr *)&connect_addr,
+                    sizeof(connect_addr)) == SOCKET_ERROR)
+                goto err;
+
+        /* Wait for incoming connection */
+        accept_s = accept(listen_s, NULL, NULL);
+        if (accept_s == SOCKET_ERROR)
+                goto err;
+
+        /* Done with listening */
+        closesocket(listen_s);
+
+        if (rd_fd_set_nonblocking(accept_s) != 0)
+                goto err;
+
+        if (rd_fd_set_nonblocking(connect_s) != 0)
+                goto err;
+
+        /* Minimize buffer sizes to avoid a large number
+         * of signaling bytes to accumulate when
+         * io-signalled queue is not being served for a while. */
+        bufsz = 100;
+        setsockopt(accept_s, SOL_SOCKET, SO_SNDBUF, (const char *)&bufsz,
+                   sizeof(bufsz));
+        bufsz = 100;
+        setsockopt(accept_s, SOL_SOCKET, SO_RCVBUF, (const char *)&bufsz,
+                   sizeof(bufsz));
+        bufsz = 100;
+        setsockopt(connect_s, SOL_SOCKET, SO_SNDBUF, (const char *)&bufsz,
+                   sizeof(bufsz));
+        bufsz = 100;
+        setsockopt(connect_s, SOL_SOCKET, SO_RCVBUF, (const char *)&bufsz,
+                   sizeof(bufsz));
+
+        /* Store resulting sockets.
+         * They are bidirectional, so it does not matter which is read or
+         * write side of pipe. */
+        fds[0] = accept_s;
+        fds[1] = connect_s;
+        return 0;
+
+err:
+        if (listen_s != INVALID_SOCKET)
+                closesocket(listen_s);
+        if (accept_s != INVALID_SOCKET)
+                closesocket(accept_s);
+        if (connect_s != INVALID_SOCKET)
+                closesocket(connect_s);
+        return -1;
+}
+
+/* Socket IO */
+#define rd_socket_read(fd, buf, sz)  recv(fd, buf, sz, 0)
+#define rd_socket_write(fd, buf, sz) send(fd, buf, sz, 0)
+#define rd_socket_close(fd)          closesocket(fd)
+
+/* File IO */
+#define rd_write(fd, buf, sz)      _write(fd, buf, sz)
+#define rd_open(path, flags, mode) _open(path, flags, mode)
+#define rd_close(fd)               _close(fd)
+
+#endif /* !__cplusplus*/
+
+#endif /* _RDWIN32_H_ */