Add non-blocking io mode setter for POSIX

lib/pure/nativesockets.nim

@@ -725,13 +725,7 @@ proc setBlocking*(s: SocketHandle, blocking: bool) =
     if ioctlsocket(s, FIONBIO, addr(mode)) == -1:
       raiseOSError(osLastError())
   else: # BSD sockets
-    var x: int = fcntl(s, F_GETFL, 0)
-    if x == -1:
-      raiseOSError(osLastError())
-    else:
-      var mode = if blocking: x and not O_NONBLOCK else: x or O_NONBLOCK
-      if fcntl(s, F_SETFL, mode) == -1:
-        raiseOSError(osLastError())
+    setNonBlocking(FileHandle(s), not blocking)
 
 proc timeValFromMilliseconds(timeout = 500): Timeval =
   if timeout != -1:

lib/system/io.nim

@@ -270,6 +270,7 @@ const SupportIoctlInheritCtl = (defined(linux) or defined(bsd)) and
                               not defined(nimscript)
 when SupportIoctlInheritCtl:
   var
+    FIONBIO {.importc, header: "<sys/ioctl.h>".}: cint
     FIOCLEX {.importc, header: "<sys/ioctl.h>".}: cint
     FIONCLEX {.importc, header: "<sys/ioctl.h>".}: cint
 
@@ -279,7 +280,10 @@ elif defined(posix) and not defined(lwip) and not defined(nimscript):
   var
     F_GETFD {.importc, header: "<fcntl.h>".}: cint
     F_SETFD {.importc, header: "<fcntl.h>".}: cint
+    F_GETFL {.importc, header: "<fcntl.h>".}: cint
+    F_SETFL {.importc, header: "<fcntl.h>".}: cint
     FD_CLOEXEC {.importc, header: "<fcntl.h>".}: cint
+    O_NONBLOCK {.importc, header: "<fcntl.h>".}: cint
 
   proc c_fcntl(fd: cint, cmd: cint): cint {.
     importc: "fcntl", header: "<fcntl.h>", varargs.}
@@ -361,6 +365,58 @@ when defined(nimdoc) or (defined(posix) and not defined(nimscript)) or defined(w
       result = setHandleInformation(cast[IoHandle](f), HANDLE_FLAG_INHERIT,
                                     inheritable.WinDWORD) != 0
 
+when defined(nimdoc) or (defined(posix) and not defined(nimscript) and not defined(windows)):
+  proc setNonBlocking*(f: FileHandle, blocking = false) {.raises: [OSError].} =
+    ## Control file handle blocking mode.
+    ##
+    ## Non-blocking IO `read`/`write` calls return immediately with whatever
+    ## result is available, without putting the current thread to sleep. The
+    ## call is expected to be tried again.
+    ##
+    ## Calling `read` on a non-blocking file handle will result in an `IOError`
+    ## of 'Resource temporarily unavailable' whenever there is no data to read.
+    ## The state can be checked beforehand with either
+    ## `endOfFile <#endOfFile,File>`_ or
+    ## `atEnd <streams.html#atEnd,Stream>`_.
+    ##
+    ## This requires the OS file handle, which can be
+    ## retrieved via `getOsFileHandle <#getOsFileHandle,File>`_.
+    ##
+    ## This procedure is available for POSIX platforms. Test for
+    ## availability with `declared() <system.html#declared,untyped>`_.
+    ##
+    ## There are separate APIs on Windows for using console handles,
+    ## pipes and sockets in a non-blocking manner. Some of which aren't
+    ## implemented in stdlib yet.
+    ##
+    ## See `setNonBlocking(File, bool) <#setNonBlocking,File>`_.
+    when not defined(windows):
+      runnableExamples:
+        setNonBlocking(getOsFileHandle(stdin))
+        doAssert(endOfFile(stdin))
+    when SupportIoctlInheritCtl:
+      let opt = if blocking: 0 else: 1
+      if c_ioctl(f, FIONBIO, unsafeAddr(opt)) == -1:
+        raise newException(OSError, "failed to set file handle mode")
+    elif defined(posix):
+      var x: int = c_fcntl(f, F_GETFL, 0)
+      if x == -1:
+        raise newException(OSError, "failed to get file handle mode")
+      else:
+        var mode = if blocking: x and not O_NONBLOCK else: x or O_NONBLOCK
+        if c_fcntl(f, F_SETFL, mode) == -1:
+          raise newException(OSError, "failed to set file handle mode")
+
+  proc setNonBlocking*(f: File, blocking = false) {.raises: [OSError].} =
+    ## Control file blocking mode.
+    ##
+    ## See `setNonBlocking(FileHandle, bool) <#setNonBlocking,FileHandle>`_.
+    when not defined(windows):
+      runnableExamples:
+        setNonBlocking(stdin)
+        doAssert(endOfFile(stdin))
+      setNonBlocking(getFileHandle(f), blocking)
+
 proc readLine*(f: File, line: var string): bool {.tags: [ReadIOEffect],
               benign.} =
   ## reads a line of text from the file `f` into `line`. May throw an IO

tests/stdlib/tio_nonblocking.nim

@@ -0,0 +1,10 @@
+discard """
+  disabled: "win"
+  targets: "c"
+"""
+
+proc main =
+  setNonBlocking(stdin)
+  doAssert(endOfFile(stdin))
+
+main()