start unifying uvloop & winloop together

Author: Vizonex

uvloop/dns.pyx

@@ -61,7 +61,7 @@ cdef __convert_sockaddr_to_pyaddr(const system.sockaddr* addr):
             addr6.sin6_scope_id
         )
 
-    elif addr.sa_family == uv.AF_UNIX:
+    elif not system.PLATFORM_IS_WINDOWS and addr.sa_family == uv.AF_UNIX:
         addr_un = <system.sockaddr_un*>addr
         return system.MakeUnixSockPyAddr(addr_un)
 
@@ -154,7 +154,7 @@ cdef __convert_pyaddr_to_sockaddr(int family, object addr,
         (<system.sockaddr_in6*>&ret.addr).sin6_flowinfo = flowinfo
         (<system.sockaddr_in6*>&ret.addr).sin6_scope_id = scope_id
 
-    elif family == uv.AF_UNIX:
+    elif not system.PLATFORM_IS_WINDOWS and family == uv.AF_UNIX:
         if isinstance(addr, str):
             addr = addr.encode(sys_getfilesystemencoding())
         elif not isinstance(addr, bytes):
@@ -170,10 +170,14 @@ cdef __convert_pyaddr_to_sockaddr(int family, object addr,
         (<system.sockaddr_un*>&ret.addr).sun_family = uv.AF_UNIX
         memcpy((<system.sockaddr_un*>&ret.addr).sun_path, buf, buflen)
 
-    else:
+    elif not system.PLATFORM_IS_WINDOWS:
         raise ValueError(
             f'expected AF_INET, AF_INET6, or AF_UNIX family, got {family}')
 
+    else:
+        raise ValueError(
+            f'expected AF_INET or AF_INET6 family, got {family}')
+
     ret.family = family
     sockaddrs[addr] = ret
     memcpy(res, &ret.addr, ret.addr_size)

uvloop/errors.pyx

@@ -8,7 +8,23 @@ cdef __convert_python_error(int uverr):
     #      Implementation detail: on Unix error codes are the
     #      negated errno (or -errno), while on Windows they
     #      are defined by libuv to arbitrary negative numbers.
-    cdef int oserr = -uverr
+
+    cdef int oserr
+    if system.PLATFORM_IS_WINDOWS:
+        # XXX Won't work for Windows:
+        # From libuv docs:
+        #      Implementation detail: on Unix error codes are the
+        #      negated errno (or -errno), while on Windows they
+        #      are defined by libuv to arbitrary negative numbers.
+
+        # Winloop comment: The following approach seems to work for Windows:
+	    # translation from uverr, which is a negative number like -4088 or -4071
+        # defined by libuv (as mentioned above), to error numbers obtained via 
+        # the Python module errno.
+        err = getattr(errno, uv.uv_err_name(uverr).decode(), uverr)
+        return OSError(err, uv.uv_strerror(uverr).decode())
+
+    oserr = -uverr
 
     exc = OSError
 

uvloop/handles/poll.pyx

@@ -10,7 +10,11 @@ cdef class UVPoll(UVHandle):
             self._abort_init()
             raise MemoryError()
 
-        err = uv.uv_poll_init(self._loop.uvloop,
+        if system.PLATFORM_IS_WINDOWS:
+            err = uv.uv_poll_init_socket(self._loop.uvloop,
+                              <uv.uv_poll_t *>self._handle, fd)
+        else:
+            err = uv.uv_poll_init(self._loop.uvloop,
                               <uv.uv_poll_t *>self._handle, fd)
         if err < 0:
             self._abort_init()

uvloop/handles/process.pyx

@@ -28,8 +28,10 @@ cdef class UVProcess(UVHandle):
                pass_fds, debug_flags, preexec_fn, restore_signals):
 
         global __forking
-        global __forking_loop
-        global __forkHandler
+
+        if not system.PLATFORM_IS_WINDOWS:
+            global __forking_loop
+            global __forkHandler
 
         cdef int err
 
@@ -89,22 +91,25 @@ cdef class UVProcess(UVHandle):
             self._restore_signals = restore_signals
 
             loop.active_process_handler = self
-            __forking = 1
-            __forking_loop = loop
-            system.setForkHandler(<system.OnForkHandler>&__get_fork_handler)
-
-            PyOS_BeforeFork()
+            if not system.PLATFORM_IS_WINDOWS:
+                __forking = 1
+                __forking_loop = loop
+                system.setForkHandler(<system.OnForkHandler>&__get_fork_handler)
 
+                PyOS_BeforeFork()
+            
             err = uv.uv_spawn(loop.uvloop,
-                              <uv.uv_process_t*>self._handle,
-                              &self.options)
-
-            __forking = 0
-            __forking_loop = None
-            system.resetForkHandler()
-            loop.active_process_handler = None
-
-            PyOS_AfterFork_Parent()
+                          <uv.uv_process_t*>self._handle,
+                          &self.options)
+            
+            if not system.PLATFORM_IS_WINDOWS:
+                __forking = 0
+                __forking_loop = None
+                system.resetForkHandler()
+
+                PyOS_AfterFork_Parent()
+            
+            
 
             if err < 0:
                 self._close_process_handle()
@@ -178,11 +183,12 @@ cdef class UVProcess(UVHandle):
         if self._restore_signals:
             _Py_RestoreSignals()
 
-        PyOS_AfterFork_Child()
+        if not system.PLATFORM_IS_WINDOWS:
+            PyOS_AfterFork_Child()
 
-        err = uv.uv_loop_fork(self._loop.uvloop)
-        if err < 0:
-            raise convert_error(err)
+            err = uv.uv_loop_fork(self._loop.uvloop)
+            if err < 0:
+                raise convert_error(err)
 
         if self._preexec_fn is not None:
             try:
@@ -775,7 +781,15 @@ cdef __socketpair():
         int fds[2]
         int err
 
-    err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)
+    # Winloop comment: no Unix sockets on Windows, using uv.uv_pipe()
+    # instead of system.socketpair(). Also, see changes to 
+    # libuv/src/win/pipe.c to deal with UV_EPERM = -4048 errors
+    # for stdin pipe.
+    if system.PLATFORM_IS_WINDOWS:
+        # NB: uv.uv_file is int type on Windows
+        err = uv.uv_pipe(fds, uv.UV_NONBLOCK_PIPE, uv.UV_NONBLOCK_PIPE)
+    else:
+        err = system.socketpair(uv.AF_UNIX, uv.SOCK_STREAM, 0, fds)
     if err:
         exc = convert_error(-err)
         raise exc

uvloop/handles/stream.pyx

@@ -355,6 +355,15 @@ cdef class UVStream(UVBaseTransport):
             Py_ssize_t blen
             int saved_errno
             int fd
+        
+        if system.PLATFORM_IS_WINDOWS:
+            # Winloop comment: WSASend below does not work with pipes.
+            # For pipes, using Writefile() from Windows fileapi.h would
+            # be an option, but the corresponding files have been created
+            # FILE_FLAG_OVERLAPPED set, but we don't want to go that way here.
+            # We detect pipes on Windows as pseudosockets.
+            if self._get_socket().family == uv.AF_UNIX:
+                return -1
 
         if (<uv.uv_stream_t*>self._handle).write_queue_size != 0:
             raise RuntimeError(
@@ -383,16 +392,17 @@ cdef class UVStream(UVBaseTransport):
         # uv_try_write -- less layers of code.  The error
         # checking logic is copied from libuv.
         written = system.write(fd, buf, blen)
-        while written == -1 and (
-                errno.errno == errno.EINTR or
-                (system.PLATFORM_IS_APPLE and
-                    errno.errno == errno.EPROTOTYPE)):
-            # From libuv code (unix/stream.c):
-            #   Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
-            #   EPROTOTYPE can be returned while trying to write to a socket
-            #   that is shutting down. If we retry the write, we should get
-            #   the expected EPIPE instead.
-            written = system.write(fd, buf, blen)
+        if not system.PLATFORM_IS_WINDOWS:
+            while written == -1 and (
+                    errno.errno == errno.EINTR or
+                    (system.PLATFORM_IS_APPLE and
+                        errno.errno == errno.EPROTOTYPE)):
+                # From libuv code (unix/stream.c):
+                #   Due to a possible kernel bug at least in OS X 10.10 "Yosemite",
+                #   EPROTOTYPE can be returned while trying to write to a socket
+                #   that is shutting down. If we retry the write, we should get
+                #   the expected EPIPE instead.
+                written = system.write(fd, buf, blen)
         saved_errno = errno.errno
 
         if used_buf:
@@ -675,6 +685,14 @@ cdef class UVStream(UVBaseTransport):
 
     cpdef write(self, object buf):
         self._ensure_alive()
+ 
+        if system.PLATFORM_IS_WINDOWS:
+            # Winloop Comment: Winloop gets itself into trouble if this is
+            # is not checked immediately, it's too costly to call the python function 
+            # bring in the flag instead to indicate closure.
+            # SEE: https://github.com/Vizonex/Winloop/issues/84 
+            if self._closing:
+                raise RuntimeError("Cannot call write() when UVStream is closing")
 
         if self._eof:
             raise RuntimeError('Cannot call write() after write_eof()')
@@ -806,7 +824,14 @@ cdef inline bint __uv_stream_on_read_common(
         if sc.__read_error_close:
             # Used for getting notified when a pipe is closed.
             # See WriteUnixTransport for the explanation.
-            sc._on_eof()
+            # Winloop comment: 0-reads on pipes used, e.g., for stdin
+            # ("write only") give ERROR_ACCESS_DENIED, and in this case
+            # we should keep the transport open for further writes.
+            if (system.PLATFORM_IS_WINDOWS and nread == uv.UV_EPERM
+                and uv.uv_is_writable(<uv.uv_stream_t*> sc._handle)):
+                sc._stop_reading()
+            else:
+                sc._on_eof()
             return True
 
         exc = convert_error(nread)

uvloop/includes/compat.h

@@ -1,8 +1,16 @@
 #include <errno.h>
 #include <stddef.h>
 #include <signal.h>
+#ifndef _WIN32
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#else
+#include <io.h>
+#include <winsock2.h>
+#endif
+
 #include "Python.h"
 #include "uv.h"
 
@@ -24,16 +32,49 @@
 #else
 #  define PLATFORM_IS_LINUX 0
 #  define EPOLL_CTL_DEL 2
-struct epoll_event {};
+/* error C2016: C requires that a struct or union have at least one member on Windows
+with default compilation flags. Therefore put dummy field for now. */
+struct epoll_event {int dummyfield;};
 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event) {
     return 0;
 };
 #endif
 
 
+#ifdef _WIN32
+int SIGCHLD = 0;
+int SO_REUSEPORT = 0;
+
+struct sockaddr_un {unsigned short sun_family; char* sun_path;};
+
+int socketpair(int domain, int type, int protocol, int socket_vector[2]) {
+    return 0;
+}
+
+/* redefine write as counterpart of unistd.h/write */
+int write(int fd, const void *buf, unsigned int count) {
+    WSABUF wsa;
+    unsigned long dbytes;
+    wsa.buf = (char*)buf;
+    wsa.len = (unsigned long)count;
+    errno = WSASend(fd, &wsa, 1, &dbytes, 0, NULL, NULL);
+    if (errno == SOCKET_ERROR) {
+      errno = WSAGetLastError();
+      if (errno == 10035)
+        errno = EAGAIN;
+      return -1;
+    }
+    else
+      return dbytes;
+}
+#endif
+
 PyObject *
 MakeUnixSockPyAddr(struct sockaddr_un *addr)
 {
+#ifdef _WIN32
+	return NULL;
+#else
     if (addr->sun_family != AF_UNIX) {
         PyErr_SetString(
             PyExc_ValueError, "a UNIX socket addr was expected");
@@ -52,8 +93,18 @@ MakeUnixSockPyAddr(struct sockaddr_un *addr)
         /* regular NULL-terminated string */
         return PyUnicode_DecodeFSDefault(addr->sun_path);
     }
+#endif /* _WIN32 */
 }
 
+#ifdef _WIN32
+#define PLATFORM_IS_WINDOWS 1
+int getuid() {
+	return 0;
+}
+#else
+#define PLATFORM_IS_WINDOWS 0
+#endif
+
 
 #if PY_VERSION_HEX < 0x03070100
 

uvloop/includes/fork_handler.h

@@ -1,6 +1,10 @@
 #ifndef UVLOOP_FORK_HANDLER_H_
 #define UVLOOP_FORK_HANDLER_H_
 
+#ifndef _WIN32
+#include <pthread.h>
+#endif
+
 volatile uint64_t MAIN_THREAD_ID = 0;
 volatile int8_t MAIN_THREAD_ID_SET = 0;
 
@@ -39,4 +43,14 @@ void setMainThreadID(uint64_t id) {
     MAIN_THREAD_ID = id;
     MAIN_THREAD_ID_SET = 1;
 }
+
+#ifdef _WIN32
+int pthread_atfork(
+	void (*prepare)(),
+	void (*parent)(),
+	void (*child)()) {
+	return 0;
+}
+#endif
+
 #endif

uvloop/includes/stdlib.pxi

@@ -146,6 +146,8 @@ cdef int subprocess_STDOUT = subprocess.STDOUT
 cdef int subprocess_DEVNULL = subprocess.DEVNULL
 cdef subprocess_SubprocessError = subprocess.SubprocessError
 
+cdef int signal_SIGABRT = signal.SIGABRT
+cdef int signal_SIGINT = signal.SIGINT
 cdef int signal_NSIG = signal.NSIG
 cdef signal_signal = signal.signal
 cdef signal_siginterrupt = signal.siginterrupt