nim-chronos/asyncdispatch2/transports/stream.nim

1569 lines
59 KiB
Nim
Raw Normal View History

2018-05-16 08:22:34 +00:00
#
# Asyncdispatch2 Stream Transport
# (c) Copyright 2018
# Status Research & Development GmbH
#
# Licensed under either of
# Apache License, version 2.0, (LICENSE-APACHEv2)
# MIT license (LICENSE-MIT)
import net, nativesockets, os, deques
import ../asyncloop, ../handles, ../sendfile
2018-05-16 08:22:34 +00:00
import common
{.deadCodeElim: on.}
2018-05-16 08:22:34 +00:00
when defined(windows):
import winlean
else:
import posix
type
2018-05-21 21:52:57 +00:00
VectorKind = enum
2018-05-22 21:03:13 +00:00
DataBuffer, # Simple buffer pointer/length
DataFile # File handle for sendfile/TransmitFile
2018-05-21 21:52:57 +00:00
StreamVector = object
2018-05-22 21:03:13 +00:00
kind: VectorKind # Writer vector source kind
buf: pointer # Writer buffer pointer
buflen: int # Writer buffer size
offset: uint # Writer vector offset
writer: Future[int] # Writer vector completion Future
2018-05-21 21:52:57 +00:00
2018-05-16 08:22:34 +00:00
TransportKind* {.pure.} = enum
2018-05-22 21:03:13 +00:00
Socket, # Socket transport
Pipe, # Pipe transport
File # File transport
2018-05-16 08:22:34 +00:00
TransportFlags* = enum
None,
# Default value
WinServerPipe,
# This is internal flag which used to differentiate between server pipe
# handle and client pipe handle.
WinNoPipeFlash
# By default `AddressFamily.Unix` transports in Windows are using
# `FlushFileBuffers()` when transport closing.
# This flag disables usage of `FlushFileBuffers()` on `AddressFamily.Unix`
# transport shutdown. If both server and client are running in the same
# thread, because of `FlushFileBuffers()` will ensure that all bytes
# or messages written to the pipe are read by the client, it is possible to
# get stuck on transport `close()`.
# Please use this flag only if you are making both client and server in
# the same thread.
when defined(windows):
const SO_UPDATE_CONNECT_CONTEXT = 0x7010
type
StreamTransport* = ref object of RootRef
fd*: AsyncFD # File descriptor
state: set[TransportState] # Current Transport state
reader: Future[void] # Current reader Future
buffer: seq[byte] # Reading buffer
offset: int # Reading buffer offset
error: ref Exception # Current error
queue: Deque[StreamVector] # Writer queue
future: Future[void] # Stream life future
# Windows specific part
rwsabuf: TWSABuf # Reader WSABUF
wwsabuf: TWSABuf # Writer WSABUF
rovl: CustomOverlapped # Reader OVERLAPPED structure
wovl: CustomOverlapped # Writer OVERLAPPED structure
roffset: int # Pending reading offset
flags: set[TransportFlags] # Internal flags
case kind*: TransportKind
of TransportKind.Socket:
domain: Domain # Socket transport domain (IPv4/IPv6)
local: TransportAddress # Local address
remote: TransportAddress # Remote address
of TransportKind.Pipe:
todo1: int
of TransportKind.File:
todo2: int
else:
type
StreamTransport* = ref object of RootRef
fd*: AsyncFD # File descriptor
state: set[TransportState] # Current Transport state
reader: Future[void] # Current reader Future
buffer: seq[byte] # Reading buffer
offset: int # Reading buffer offset
error: ref Exception # Current error
queue: Deque[StreamVector] # Writer queue
future: Future[void] # Stream life future
case kind*: TransportKind
of TransportKind.Socket:
domain: Domain # Socket transport domain (IPv4/IPv6)
local: TransportAddress # Local address
remote: TransportAddress # Remote address
of TransportKind.Pipe:
todo1: int
of TransportKind.File:
todo2: int
2018-05-16 08:22:34 +00:00
type
2018-05-22 22:29:07 +00:00
StreamCallback* = proc(server: StreamServer,
client: StreamTransport): Future[void] {.gcsafe.}
2018-05-28 23:35:15 +00:00
## New remote client connection callback
## ``server`` - StreamServer object.
## ``client`` - accepted client transport.
2018-05-16 08:22:34 +00:00
TransportInitCallback* = proc(server: StreamServer,
fd: AsyncFD): StreamTransport {.gcsafe.}
## Custom transport initialization procedure, which can allocate inherited
## StreamTransport object.
2018-05-16 08:22:34 +00:00
StreamServer* = ref object of SocketServer
## StreamServer object
function*: StreamCallback # callback which will be called after new
# client accepted
init*: TransportInitCallback # callback which will be called before
# transport for new client
2018-05-16 08:22:34 +00:00
proc remoteAddress*(transp: StreamTransport): TransportAddress =
## Returns ``transp`` remote socket address.
if transp.kind != TransportKind.Socket:
raise newException(TransportError, "Socket required!")
if transp.remote.family == AddressFamily.None:
2018-05-16 08:22:34 +00:00
var saddr: Sockaddr_storage
var slen = SockLen(sizeof(saddr))
if getpeername(SocketHandle(transp.fd), cast[ptr SockAddr](addr saddr),
addr slen) != 0:
raiseTransportOsError(osLastError())
fromSAddr(addr saddr, slen, transp.remote)
2018-05-16 08:22:34 +00:00
result = transp.remote
proc localAddress*(transp: StreamTransport): TransportAddress =
## Returns ``transp`` local socket address.
if transp.kind != TransportKind.Socket:
raise newException(TransportError, "Socket required!")
if transp.local.family == AddressFamily.None:
2018-05-16 08:22:34 +00:00
var saddr: Sockaddr_storage
var slen = SockLen(sizeof(saddr))
if getsockname(SocketHandle(transp.fd), cast[ptr SockAddr](addr saddr),
addr slen) != 0:
raiseTransportOsError(osLastError())
fromSAddr(addr saddr, slen, transp.local)
2018-05-16 08:22:34 +00:00
result = transp.local
template setReadError(t, e: untyped) =
(t).state.incl(ReadError)
(t).error = getTransportOsError(e)
2018-05-16 08:22:34 +00:00
template checkPending(t: untyped) =
if not isNil((t).reader):
raise newException(TransportError, "Read operation already pending!")
template shiftBuffer(t, c: untyped) =
if (t).offset > c:
moveMem(addr((t).buffer[0]), addr((t).buffer[(c)]), (t).offset - (c))
(t).offset = (t).offset - (c)
else:
(t).offset = 0
2018-05-21 21:52:57 +00:00
template shiftVectorBuffer(v, o: untyped) =
(v).buf = cast[pointer](cast[uint]((v).buf) + uint(o))
(v).buflen -= int(o)
template shiftVectorFile(v, o: untyped) =
(v).buf = cast[pointer](cast[uint]((v).buf) - cast[uint](o))
(v).offset += cast[uint]((o))
2018-05-16 08:22:34 +00:00
when defined(windows):
template zeroOvelappedOffset(t: untyped) =
(t).offset = 0
(t).offsetHigh = 0
template setOverlappedOffset(t, o: untyped) =
(t).offset = cast[int32](cast[uint64](o) and 0xFFFFFFFF'u64)
(t).offsetHigh = cast[int32](cast[uint64](o) shr 32)
2018-05-21 21:52:57 +00:00
template getFileSize(v: untyped): uint =
cast[uint]((v).buf)
2018-05-16 08:22:34 +00:00
2018-05-21 21:52:57 +00:00
template getFileHandle(v: untyped): Handle =
cast[Handle]((v).buflen)
2018-05-16 08:22:34 +00:00
template slideBuffer(t, o: untyped) =
2018-05-21 21:52:57 +00:00
(t).wwsabuf.buf = cast[cstring](cast[uint]((t).wwsabuf.buf) + uint(o))
(t).wwsabuf.len -= int32(o)
2018-05-16 08:22:34 +00:00
2018-05-21 21:52:57 +00:00
template setReaderWSABuffer(t: untyped) =
(t).rwsabuf.buf = cast[cstring](
2018-05-16 08:22:34 +00:00
cast[uint](addr t.buffer[0]) + uint((t).roffset))
2018-05-21 21:52:57 +00:00
(t).rwsabuf.len = int32(len((t).buffer) - (t).roffset)
2018-05-16 08:22:34 +00:00
2018-05-21 21:52:57 +00:00
template setWriterWSABuffer(t, v: untyped) =
(t).wwsabuf.buf = cast[cstring](v.buf)
(t).wwsabuf.len = cast[int32](v.buflen)
2018-05-16 08:22:34 +00:00
2018-05-22 16:27:20 +00:00
proc writeStreamLoop(udata: pointer) {.gcsafe, nimcall.} =
2018-05-16 08:22:34 +00:00
var bytesCount: int32
2018-05-21 21:52:57 +00:00
var ovl = cast[PtrCustomOverlapped](udata)
var transp = cast[StreamTransport](ovl.data.udata)
2018-05-16 08:22:34 +00:00
while len(transp.queue) > 0:
if WritePending in transp.state:
## Continuation
transp.state.excl(WritePending)
let err = transp.wovl.data.errCode
if err == OSErrorCode(-1):
bytesCount = transp.wovl.data.bytesCount
var vector = transp.queue.popFirst()
if bytesCount == 0:
vector.writer.complete(0)
2018-05-16 08:22:34 +00:00
else:
if transp.kind == TransportKind.Socket:
if vector.kind == VectorKind.DataBuffer:
2018-05-21 21:52:57 +00:00
if bytesCount < transp.wwsabuf.len:
vector.shiftVectorBuffer(bytesCount)
2018-05-16 08:22:34 +00:00
transp.queue.addFirst(vector)
else:
vector.writer.complete(transp.wwsabuf.len)
2018-05-16 08:22:34 +00:00
else:
if uint(bytesCount) < getFileSize(vector):
2018-05-21 21:52:57 +00:00
vector.shiftVectorFile(bytesCount)
2018-05-16 08:22:34 +00:00
transp.queue.addFirst(vector)
else:
vector.writer.complete(int(getFileSize(vector)))
elif transp.kind == TransportKind.Pipe:
if vector.kind == VectorKind.DataBuffer:
if bytesCount < transp.wwsabuf.len:
vector.shiftVectorBuffer(bytesCount)
transp.queue.addFirst(vector)
else:
vector.writer.complete(transp.wwsabuf.len)
2018-05-28 23:35:15 +00:00
elif int(err) == ERROR_OPERATION_ABORTED:
# CancelIO() interrupt
transp.state.incl(WritePaused)
let v = transp.queue.popFirst()
v.writer.complete(0)
break
2018-05-16 08:22:34 +00:00
else:
let v = transp.queue.popFirst()
transp.state.incl(WriteError)
v.writer.fail(getTransportOsError(err))
2018-05-16 08:22:34 +00:00
else:
## Initiation
transp.state.incl(WritePending)
if transp.kind == TransportKind.Socket:
let sock = SocketHandle(transp.wovl.data.fd)
var vector = transp.queue.popFirst()
if vector.kind == VectorKind.DataBuffer:
2018-05-16 08:22:34 +00:00
transp.wovl.zeroOvelappedOffset()
2018-05-21 21:52:57 +00:00
transp.setWriterWSABuffer(vector)
let ret = WSASend(sock, addr transp.wwsabuf, 1,
2018-05-16 08:22:34 +00:00
addr bytesCount, DWORD(0),
cast[POVERLAPPED](addr transp.wovl), nil)
if ret != 0:
let err = osLastError()
if int(err) == ERROR_OPERATION_ABORTED:
2018-05-28 23:35:15 +00:00
# CancelIO() interrupt
2018-05-21 21:52:57 +00:00
transp.state.excl(WritePending)
transp.state.incl(WritePaused)
vector.writer.complete(0)
elif int(err) == ERROR_IO_PENDING:
transp.queue.addFirst(vector)
else:
2018-05-16 08:22:34 +00:00
transp.state.excl(WritePending)
transp.state = transp.state + {WritePaused, WriteError}
vector.writer.fail(getTransportOsError(err))
else:
transp.queue.addFirst(vector)
2018-05-16 08:22:34 +00:00
else:
let loop = getGlobalDispatcher()
var size: int32
var flags: int32
if getFileSize(vector) > 2_147_483_646'u:
size = 2_147_483_646
else:
size = int32(getFileSize(vector))
transp.wovl.setOverlappedOffset(vector.offset)
var ret = loop.transmitFile(sock, getFileHandle(vector), size, 0,
cast[POVERLAPPED](addr transp.wovl),
nil, flags)
if ret == 0:
let err = osLastError()
if int(err) == ERROR_OPERATION_ABORTED:
2018-05-28 23:35:15 +00:00
# CancelIO() interrupt
2018-05-21 21:52:57 +00:00
transp.state.excl(WritePending)
transp.state.incl(WritePaused)
vector.writer.complete(0)
elif int(err) == ERROR_IO_PENDING:
transp.queue.addFirst(vector)
else:
2018-05-16 08:22:34 +00:00
transp.state.excl(WritePending)
transp.state = transp.state + {WritePaused, WriteError}
vector.writer.fail(getTransportOsError(err))
else:
transp.queue.addFirst(vector)
elif transp.kind == TransportKind.Pipe:
let pipe = Handle(transp.wovl.data.fd)
var vector = transp.queue.popFirst()
if vector.kind == VectorKind.DataBuffer:
transp.wovl.zeroOvelappedOffset()
transp.setWriterWSABuffer(vector)
let ret = writeFile(pipe, cast[pointer](transp.wwsabuf.buf),
DWORD(transp.wwsabuf.len), addr bytesCount,
cast[POVERLAPPED](addr transp.wovl))
if ret == 0:
let err = osLastError()
if int(err) == ERROR_OPERATION_ABORTED:
# CancelIO() interrupt
transp.state.excl(WritePending)
transp.state.incl(WritePaused)
vector.writer.complete(0)
elif int(err) == ERROR_IO_PENDING:
transp.queue.addFirst(vector)
elif int(err) == ERROR_NO_DATA:
# The pipe is being closed.
transp.state.excl(WritePending)
transp.state.incl(WritePaused)
vector.writer.complete(0)
else:
transp.state.excl(WritePending)
transp.state = transp.state + {WritePaused, WriteError}
vector.writer.fail(getTransportOsError(err))
else:
transp.queue.addFirst(vector)
2018-05-16 08:22:34 +00:00
break
if len(transp.queue) == 0:
transp.state.incl(WritePaused)
2018-05-22 16:27:20 +00:00
proc readStreamLoop(udata: pointer) {.gcsafe, nimcall.} =
2018-05-21 21:52:57 +00:00
var ovl = cast[PtrCustomOverlapped](udata)
var transp = cast[StreamTransport](ovl.data.udata)
2018-05-16 08:22:34 +00:00
while true:
if ReadPending in transp.state:
## Continuation
2018-05-21 21:52:57 +00:00
transp.state.excl(ReadPending)
2018-05-16 08:22:34 +00:00
if ReadClosed in transp.state:
transp.state.incl({ReadPaused})
if not isNil(transp.reader):
if not transp.reader.finished:
transp.reader.complete()
transp.reader = nil
2018-05-16 08:22:34 +00:00
break
let err = transp.rovl.data.errCode
if err == OSErrorCode(-1):
let bytesCount = transp.rovl.data.bytesCount
if bytesCount == 0:
transp.state.incl({ReadEof, ReadPaused})
2018-05-16 08:22:34 +00:00
else:
if transp.offset != transp.roffset:
moveMem(addr transp.buffer[transp.offset],
addr transp.buffer[transp.roffset],
bytesCount)
transp.offset += bytesCount
transp.roffset = transp.offset
if transp.offset == len(transp.buffer):
transp.state.incl(ReadPaused)
2018-05-28 23:35:15 +00:00
elif int(err) == ERROR_OPERATION_ABORTED:
# CancelIO() interrupt
transp.state.incl(ReadPaused)
elif transp.kind == TransportKind.Socket and
(int(err) in {ERROR_NETNAME_DELETED, WSAECONNABORTED}):
transp.state.incl({ReadEof, ReadPaused})
elif transp.kind == TransportKind.Pipe and
(int(err) in {ERROR_BROKEN_PIPE, ERROR_PIPE_NOT_CONNECTED}):
transp.state.incl({ReadEof, ReadPaused})
2018-05-16 08:22:34 +00:00
else:
transp.setReadError(err)
if not isNil(transp.reader):
if not transp.reader.finished:
transp.reader.complete()
transp.reader = nil
2018-05-21 21:52:57 +00:00
if ReadPaused in transp.state:
# Transport buffer is full, so we will not continue on reading.
break
2018-05-16 08:22:34 +00:00
else:
## Initiation
2018-05-21 21:52:57 +00:00
if transp.state * {ReadEof, ReadClosed, ReadError} == {}:
2018-05-16 08:22:34 +00:00
var flags = DWORD(0)
var bytesCount: int32 = 0
transp.state.excl(ReadPaused)
transp.state.incl(ReadPending)
if transp.kind == TransportKind.Socket:
let sock = SocketHandle(transp.rovl.data.fd)
2018-05-21 21:52:57 +00:00
transp.roffset = transp.offset
transp.setReaderWSABuffer()
let ret = WSARecv(sock, addr transp.rwsabuf, 1,
2018-05-16 08:22:34 +00:00
addr bytesCount, addr flags,
cast[POVERLAPPED](addr transp.rovl), nil)
if ret != 0:
let err = osLastError()
if int32(err) == ERROR_OPERATION_ABORTED:
2018-05-28 23:35:15 +00:00
# CancelIO() interrupt
2018-05-21 21:52:57 +00:00
transp.state.excl(ReadPending)
2018-05-16 08:22:34 +00:00
transp.state.incl(ReadPaused)
2018-07-24 15:43:30 +00:00
elif int32(err) in {WSAECONNRESET, WSAENETRESET, WSAECONNABORTED}:
transp.state.excl(ReadPending)
transp.state.incl({ReadEof, ReadPaused})
if not isNil(transp.reader):
transp.reader.complete()
transp.reader = nil
2018-05-16 08:22:34 +00:00
elif int32(err) != ERROR_IO_PENDING:
transp.state.excl(ReadPending)
transp.state.incl(ReadPaused)
2018-05-16 08:22:34 +00:00
transp.setReadError(err)
if not isNil(transp.reader):
transp.reader.complete()
transp.reader = nil
elif transp.kind == TransportKind.Pipe:
let pipe = Handle(transp.rovl.data.fd)
transp.roffset = transp.offset
transp.setReaderWSABuffer()
let ret = readFile(pipe, cast[pointer](transp.rwsabuf.buf),
DWORD(transp.rwsabuf.len), addr bytesCount,
cast[POVERLAPPED](addr transp.rovl))
if ret == 0:
let err = osLastError()
if int32(err) == ERROR_OPERATION_ABORTED:
# CancelIO() interrupt
transp.state.excl(ReadPending)
transp.state.incl(ReadPaused)
elif int32(err) in {ERROR_BROKEN_PIPE, ERROR_PIPE_NOT_CONNECTED}:
transp.state.excl(ReadPending)
transp.state.incl({ReadEof, ReadPaused})
if not isNil(transp.reader):
transp.reader.complete()
transp.reader = nil
elif int32(err) != ERROR_IO_PENDING:
transp.state.excl(ReadPending)
transp.state.incl(ReadPaused)
transp.setReadError(err)
if not isNil(transp.reader):
transp.reader.complete()
transp.reader = nil
else:
transp.state.incl(ReadPaused)
if not isNil(transp.reader):
transp.reader.complete()
transp.reader = nil
2018-05-16 08:22:34 +00:00
## Finish Loop
break
proc newStreamSocketTransport(sock: AsyncFD, bufsize: int,
child: StreamTransport): StreamTransport =
var transp: StreamTransport
if not isNil(child):
transp = child
else:
transp = StreamTransport(kind: TransportKind.Socket)
2018-05-21 21:52:57 +00:00
transp.fd = sock
transp.rovl.data = CompletionData(fd: sock, cb: readStreamLoop,
udata: cast[pointer](transp))
transp.wovl.data = CompletionData(fd: sock, cb: writeStreamLoop,
udata: cast[pointer](transp))
transp.buffer = newSeq[byte](bufsize)
transp.state = {ReadPaused, WritePaused}
transp.queue = initDeque[StreamVector]()
transp.future = newFuture[void]("stream.socket.transport")
GC_ref(transp)
result = transp
2018-05-16 08:22:34 +00:00
proc newStreamPipeTransport(fd: AsyncFD, bufsize: int,
child: StreamTransport,
flags: set[TransportFlags] = {}): StreamTransport =
var transp: StreamTransport
if not isNil(child):
transp = child
else:
transp = StreamTransport(kind: TransportKind.Pipe)
transp.fd = fd
transp.rovl.data = CompletionData(fd: fd, cb: readStreamLoop,
udata: cast[pointer](transp))
transp.wovl.data = CompletionData(fd: fd, cb: writeStreamLoop,
udata: cast[pointer](transp))
transp.buffer = newSeq[byte](bufsize)
transp.flags = flags
transp.state = {ReadPaused, WritePaused}
transp.queue = initDeque[StreamVector]()
transp.future = newFuture[void]("stream.pipe.transport")
GC_ref(transp)
result = transp
2018-05-16 08:22:34 +00:00
proc bindToDomain(handle: AsyncFD, domain: Domain): bool =
result = true
if domain == Domain.AF_INET6:
var saddr: Sockaddr_in6
saddr.sin6_family = type(saddr.sin6_family)(toInt(domain))
2018-05-16 08:22:34 +00:00
if bindAddr(SocketHandle(handle), cast[ptr SockAddr](addr(saddr)),
sizeof(saddr).SockLen) != 0'i32:
result = false
elif domain == Domain.AF_INET:
2018-05-16 08:22:34 +00:00
var saddr: Sockaddr_in
saddr.sin_family = type(saddr.sin_family)(toInt(domain))
2018-05-16 08:22:34 +00:00
if bindAddr(SocketHandle(handle), cast[ptr SockAddr](addr(saddr)),
sizeof(saddr).SockLen) != 0'i32:
result = false
proc connect*(address: TransportAddress,
bufferSize = DefaultStreamBufferSize,
child: StreamTransport = nil,
flags: set[TransportFlags] = {}): Future[StreamTransport] =
## Open new connection to remote peer with address ``address`` and create
## new transport object ``StreamTransport`` for established connection.
2018-05-28 23:35:15 +00:00
## ``bufferSize`` is size of internal buffer for transport.
2018-05-16 08:22:34 +00:00
let loop = getGlobalDispatcher()
var retFuture = newFuture[StreamTransport]("stream.transport.connect")
if address.family in {AddressFamily.IPv4, AddressFamily.IPv6}:
## Socket handling part
var
saddr: Sockaddr_storage
slen: SockLen
sock: AsyncFD
povl: RefCustomOverlapped
proto: Protocol
toSAddr(address, saddr, slen)
proto = Protocol.IPPROTO_TCP
sock = createAsyncSocket(address.getDomain(), SockType.SOCK_STREAM, proto)
if sock == asyncInvalidSocket:
result.fail(getTransportOsError(osLastError()))
2018-05-16 08:22:34 +00:00
if not bindToDomain(sock, address.getDomain()):
let err = wsaGetLastError()
sock.closeSocket()
retFuture.fail(getTransportOsError(err))
return retFuture
2018-05-16 08:22:34 +00:00
proc socketContinuation(udata: pointer) =
var ovl = cast[RefCustomOverlapped](udata)
if not retFuture.finished:
if ovl.data.errCode == OSErrorCode(-1):
if setsockopt(SocketHandle(sock), cint(SOL_SOCKET),
cint(SO_UPDATE_CONNECT_CONTEXT), nil,
SockLen(0)) != 0'i32:
let err = wsaGetLastError()
sock.closeSocket()
retFuture.fail(getTransportOsError(err))
else:
retFuture.complete(newStreamSocketTransport(povl.data.fd,
bufferSize,
child))
else:
sock.closeSocket()
retFuture.fail(getTransportOsError(ovl.data.errCode))
GC_unref(ovl)
povl = RefCustomOverlapped()
GC_ref(povl)
povl.data = CompletionData(fd: sock, cb: socketContinuation)
if address.family in {AddressFamily.IPv4, AddressFamily.IPv6}:
var res = loop.connectEx(SocketHandle(sock),
cast[ptr SockAddr](addr saddr),
DWORD(slen), nil, 0, nil,
cast[POVERLAPPED](povl))
# We will not process immediate completion, to avoid undefined behavior.
if not res:
let err = osLastError()
if int32(err) != ERROR_IO_PENDING:
GC_unref(povl)
sock.closeSocket()
retFuture.fail(getTransportOsError(err))
elif address.family == AddressFamily.Unix:
## Unix domain socket emulation with Windows Named Pipes.
proc pipeContinuation(udata: pointer) {.gcsafe.} =
var pipeSuffix = $cast[cstring](unsafeAddr address.address_un[0])
var pipeName = newWideCString(r"\\.\pipe\" & pipeSuffix[1 .. ^1])
var pipeHandle = createFileW(pipeName, GENERIC_READ or GENERIC_WRITE,
FILE_SHARE_READ or FILE_SHARE_WRITE,
nil, OPEN_EXISTING,
FILE_FLAG_OVERLAPPED, Handle(0))
if pipeHandle == INVALID_HANDLE_VALUE:
let err = osLastError()
if int32(err) == ERROR_PIPE_BUSY:
addTimer(fastEpochTime() + 50, pipeContinuation, nil)
2018-05-16 08:22:34 +00:00
else:
retFuture.fail(getTransportOsError(err))
2018-05-16 08:22:34 +00:00
else:
register(AsyncFD(pipeHandle))
retFuture.complete(newStreamPipeTransport(AsyncFD(pipeHandle),
bufferSize, child))
pipeContinuation(nil)
2018-05-16 08:22:34 +00:00
return retFuture
proc acceptPipeLoop(udata: pointer) {.gcsafe, nimcall.} =
var ovl = cast[PtrCustomOverlapped](udata)
var server = cast[StreamServer](ovl.data.udata)
var loop = getGlobalDispatcher()
while true:
if server.apending:
## Continuation
server.apending = false
if server.status in {ServerStatus.Stopped, ServerStatus.Closed}:
break
else:
if ovl.data.errCode == OSErrorCode(-1):
var ntransp: StreamTransport
var flags = {WinServerPipe}
if NoPipeFlash in server.flags:
flags.incl(WinNoPipeFlash)
if not isNil(server.init):
var transp = server.init(server, server.sock)
ntransp = newStreamPipeTransport(server.sock, server.bufferSize,
transp, flags)
else:
ntransp = newStreamPipeTransport(server.sock, server.bufferSize,
nil, flags)
asyncCheck server.function(server, ntransp)
elif int32(ovl.data.errCode) == ERROR_OPERATION_ABORTED:
# CancelIO() interrupt
break
else:
doAssert disconnectNamedPipe(Handle(server.sock)) == 1
doAssert closeHandle(HANDLE(server.sock)) == 1
raiseTransportOsError(osLastError())
else:
## Initiation
server.apending = true
if server.status in {ServerStatus.Stopped, ServerStatus.Closed}:
## Server was already stopped/closed exiting
break
var pipeSuffix = $cast[cstring](addr server.local.address_un)
var pipeName = newWideCString(r"\\.\pipe\" & pipeSuffix[1 .. ^1])
var openMode = PIPE_ACCESS_DUPLEX or FILE_FLAG_OVERLAPPED
if FirstPipe notin server.flags:
openMode = openMode or FILE_FLAG_FIRST_PIPE_INSTANCE
server.flags.incl(FirstPipe)
let pipeMode = int32(PIPE_TYPE_BYTE or PIPE_READMODE_BYTE or PIPE_WAIT)
let pipeHandle = createNamedPipe(pipeName, openMode, pipeMode,
PIPE_UNLIMITED_INSTANCES,
DWORD(server.bufferSize),
DWORD(server.bufferSize),
DWORD(0), nil)
if pipeHandle == INVALID_HANDLE_VALUE:
raiseTransportOsError(osLastError())
server.sock = AsyncFD(pipeHandle)
server.aovl.data.fd = AsyncFD(pipeHandle)
register(server.sock)
let res = connectNamedPipe(pipeHandle,
cast[POVERLAPPED](addr server.aovl))
if res == 0:
let err = osLastError()
if int32(err) == ERROR_IO_PENDING:
discard
elif int32(err) == ERROR_PIPE_CONNECTED:
discard
else:
raiseTransportOsError(err)
break
proc acceptLoop(udata: pointer) {.gcsafe, nimcall.} =
var ovl = cast[PtrCustomOverlapped](udata)
var server = cast[StreamServer](ovl.data.udata)
var loop = getGlobalDispatcher()
2018-05-16 08:22:34 +00:00
while true:
if server.apending:
## Continuation
server.apending = false
if server.status in {ServerStatus.Stopped, ServerStatus.Closed}:
## Server was already stopped/closed exiting
server.asock.closeSocket()
break
2018-05-16 08:22:34 +00:00
else:
if ovl.data.errCode == OSErrorCode(-1):
if setsockopt(SocketHandle(server.asock), cint(SOL_SOCKET),
cint(SO_UPDATE_ACCEPT_CONTEXT), addr server.sock,
2018-05-16 08:22:34 +00:00
SockLen(sizeof(SocketHandle))) != 0'i32:
let err = OSErrorCode(wsaGetLastError())
server.asock.closeSocket()
raiseTransportOsError(err)
2018-05-16 08:22:34 +00:00
else:
var ntransp: StreamTransport
if not isNil(server.init):
let transp = server.init(server, server.asock)
ntransp = newStreamSocketTransport(server.asock,
server.bufferSize,
transp)
else:
ntransp = newStreamSocketTransport(server.asock,
server.bufferSize, nil)
asyncCheck server.function(server, ntransp)
2018-05-23 11:03:18 +00:00
elif int32(ovl.data.errCode) == ERROR_OPERATION_ABORTED:
2018-05-28 23:35:15 +00:00
# CancelIO() interrupt
server.asock.closeSocket()
break
2018-05-16 08:22:34 +00:00
else:
server.asock.closeSocket()
raiseTransportOsError(ovl.data.errCode)
else:
## Initiation
if server.status in {ServerStatus.Stopped, ServerStatus.Closed}:
## Server was already stopped/closed exiting
break
server.apending = true
server.asock = createAsyncSocket(server.domain, SockType.SOCK_STREAM,
Protocol.IPPROTO_TCP)
if server.asock == asyncInvalidSocket:
raiseTransportOsError(OSErrorCode(wsaGetLastError()))
var dwBytesReceived = DWORD(0)
let dwReceiveDataLength = DWORD(0)
let dwLocalAddressLength = DWORD(sizeof(Sockaddr_in6) + 16)
let dwRemoteAddressLength = DWORD(sizeof(Sockaddr_in6) + 16)
let res = loop.acceptEx(SocketHandle(server.sock),
SocketHandle(server.asock),
addr server.abuffer[0],
dwReceiveDataLength, dwLocalAddressLength,
dwRemoteAddressLength, addr dwBytesReceived,
cast[POVERLAPPED](addr server.aovl))
if not res:
let err = osLastError()
if int32(err) == ERROR_OPERATION_ABORTED:
server.apending = false
break
elif int32(err) == ERROR_IO_PENDING:
discard
else:
raiseTransportOsError(err)
break
2018-05-16 08:22:34 +00:00
proc resumeRead(transp: StreamTransport) {.inline.} =
transp.state.excl(ReadPaused)
readStreamLoop(cast[pointer](addr transp.rovl))
2018-05-16 08:22:34 +00:00
proc resumeWrite(transp: StreamTransport) {.inline.} =
transp.state.excl(WritePaused)
writeStreamLoop(cast[pointer](addr transp.wovl))
2018-05-16 08:22:34 +00:00
proc pauseAccept(server: StreamServer) {.inline.} =
if server.apending:
discard cancelIO(Handle(server.sock))
proc resumeAccept(server: StreamServer) {.inline.} =
if not server.apending:
server.aovl.data.cb(addr server.aovl)
2018-05-16 08:22:34 +00:00
else:
template getVectorBuffer(v: untyped): pointer =
cast[pointer](cast[uint]((v).buf) + uint((v).boffset))
template getVectorLength(v: untyped): int =
cast[int]((v).buflen - int((v).boffset))
template initBufferStreamVector(v, p, n, t: untyped) =
(v).kind = DataBuffer
(v).buf = cast[pointer]((p))
(v).buflen = int(n)
(v).writer = (t)
proc writeStreamLoop(udata: pointer) {.gcsafe.} =
var cdata = cast[ptr CompletionData](udata)
var transp = cast[StreamTransport](cdata.udata)
2018-05-16 08:22:34 +00:00
let fd = SocketHandle(cdata.fd)
if int(fd) == 0:
## This situation can be happen, when there events present
## after transport was closed.
return
2018-05-28 23:35:15 +00:00
if len(transp.queue) > 0:
var vector = transp.queue.popFirst()
while true:
if transp.kind == TransportKind.Socket:
if vector.kind == VectorKind.DataBuffer:
let res = posix.send(fd, vector.buf, vector.buflen, MSG_NOSIGNAL)
if res >= 0:
if vector.buflen - res == 0:
vector.writer.complete(vector.buflen)
2018-05-16 08:22:34 +00:00
else:
2018-05-28 23:35:15 +00:00
vector.shiftVectorBuffer(res)
transp.queue.addFirst(vector)
2018-05-16 08:22:34 +00:00
else:
2018-05-28 23:35:15 +00:00
let err = osLastError()
if int(err) == EINTR:
continue
2018-05-21 21:52:57 +00:00
else:
vector.writer.fail(getTransportOsError(err))
2018-05-28 23:35:15 +00:00
else:
let res = sendfile(int(fd), cast[int](vector.buflen),
int(vector.offset),
cast[int](vector.buf))
if res >= 0:
if cast[int](vector.buf) - res == 0:
vector.writer.complete(cast[int](vector.buf))
2018-05-28 23:35:15 +00:00
else:
vector.shiftVectorFile(res)
transp.queue.addFirst(vector)
else:
let err = osLastError()
if int(err) == EINTR:
continue
else:
vector.writer.fail(getTransportOsError(err))
break
2018-05-28 23:35:15 +00:00
else:
transp.state.incl(WritePaused)
transp.fd.removeWriter()
2018-05-16 08:22:34 +00:00
proc readStreamLoop(udata: pointer) {.gcsafe.} =
var cdata = cast[ptr CompletionData](udata)
var transp = cast[StreamTransport](cdata.udata)
2018-05-16 08:22:34 +00:00
let fd = SocketHandle(cdata.fd)
if int(fd) == 0:
## This situation can be happen, when there events present
## after transport was closed.
return
if ReadClosed in transp.state:
transp.state.incl({ReadPaused})
if not isNil(transp.reader):
if not transp.reader.finished:
transp.reader.complete()
transp.reader = nil
else:
while true:
var res = posix.recv(fd, addr transp.buffer[transp.offset],
len(transp.buffer) - transp.offset, cint(0))
if res < 0:
let err = osLastError()
if int(err) == EINTR:
continue
elif int(err) in {ECONNRESET}:
transp.state.incl({ReadEof, ReadPaused})
cdata.fd.removeReader()
else:
transp.state.incl(ReadPaused)
transp.setReadError(err)
cdata.fd.removeReader()
elif res == 0:
2018-07-24 15:43:30 +00:00
transp.state.incl({ReadEof, ReadPaused})
2018-05-16 08:22:34 +00:00
cdata.fd.removeReader()
else:
transp.offset += res
if transp.offset == len(transp.buffer):
transp.state.incl(ReadPaused)
cdata.fd.removeReader()
if not isNil(transp.reader):
transp.reader.complete()
transp.reader = nil
break
2018-05-16 08:22:34 +00:00
proc newStreamSocketTransport(sock: AsyncFD, bufsize: int,
child: StreamTransport): StreamTransport =
var transp: StreamTransport
if not isNil(child):
transp = child
else:
transp = StreamTransport(kind: TransportKind.Socket)
2018-05-21 21:52:57 +00:00
transp.fd = sock
transp.buffer = newSeq[byte](bufsize)
transp.state = {ReadPaused, WritePaused}
transp.queue = initDeque[StreamVector]()
transp.future = newFuture[void]("socket.stream.transport")
GC_ref(transp)
result = transp
2018-05-16 08:22:34 +00:00
proc connect*(address: TransportAddress,
bufferSize = DefaultStreamBufferSize,
child: StreamTransport = nil): Future[StreamTransport] =
## Open new connection to remote peer with address ``address`` and create
## new transport object ``StreamTransport`` for established connection.
## ``bufferSize`` - size of internal buffer for transport.
2018-05-16 08:22:34 +00:00
var
saddr: Sockaddr_storage
slen: SockLen
sock: AsyncFD
proto: Protocol
2018-05-16 08:22:34 +00:00
var retFuture = newFuture[StreamTransport]("transport.connect")
address.toSAddr(saddr, slen)
proto = Protocol.IPPROTO_TCP
if address.family == AddressFamily.Unix:
# `Protocol` enum is missing `0` value, so we making here cast, until
# `Protocol` enum will not support IPPROTO_IP == 0.
proto = cast[Protocol](0)
sock = createAsyncSocket(address.getDomain(), SockType.SOCK_STREAM,
proto)
2018-05-16 08:22:34 +00:00
if sock == asyncInvalidSocket:
retFuture.fail(getTransportOsError(osLastError()))
2018-06-07 19:07:17 +00:00
return retFuture
2018-05-16 08:22:34 +00:00
proc continuation(udata: pointer) =
var data = cast[ptr CompletionData](udata)
var err = 0
2018-05-23 11:03:18 +00:00
let fd = data.fd
fd.removeWriter()
2018-05-23 11:03:18 +00:00
if not fd.getSocketError(err):
closeSocket(fd)
retFuture.fail(getTransportOsError(osLastError()))
2018-05-16 08:22:34 +00:00
return
if err != 0:
closeSocket(fd)
retFuture.fail(getTransportOsError(OSErrorCode(err)))
2018-05-16 08:22:34 +00:00
return
retFuture.complete(newStreamSocketTransport(fd, bufferSize, child))
2018-05-16 08:22:34 +00:00
while true:
var res = posix.connect(SocketHandle(sock),
cast[ptr SockAddr](addr saddr), slen)
if res == 0:
retFuture.complete(newStreamSocketTransport(sock, bufferSize, child))
2018-05-16 08:22:34 +00:00
break
else:
let err = osLastError()
if int(err) == EINTR:
continue
elif int(err) == EINPROGRESS:
sock.addWriter(continuation)
break
else:
sock.closeSocket()
retFuture.fail(getTransportOsError(err))
2018-05-16 08:22:34 +00:00
break
return retFuture
proc acceptLoop(udata: pointer) =
2018-05-16 08:22:34 +00:00
var
saddr: Sockaddr_storage
slen: SockLen
var server = cast[StreamServer](cast[ptr CompletionData](udata).udata)
while true:
let res = posix.accept(SocketHandle(server.sock),
cast[ptr SockAddr](addr saddr), addr slen)
if int(res) > 0:
let sock = wrapAsyncSocket(res)
if sock != asyncInvalidSocket:
if not isNil(server.init):
var transp = server.init(server, sock)
2018-06-18 20:57:40 +00:00
asyncCheck server.function(server,
newStreamSocketTransport(sock, server.bufferSize, transp))
else:
2018-06-18 20:57:40 +00:00
asyncCheck server.function(server,
newStreamSocketTransport(sock, server.bufferSize, nil))
2018-05-16 08:22:34 +00:00
break
else:
let err = osLastError()
if int(err) == EINTR:
continue
else:
2018-05-16 08:22:34 +00:00
## Critical unrecoverable error
raiseTransportOsError(err)
2018-05-16 08:22:34 +00:00
proc resumeAccept(server: StreamServer) =
addReader(server.sock, acceptLoop, cast[pointer](server))
proc pauseAccept(server: StreamServer) =
removeReader(server.sock)
2018-05-16 08:22:34 +00:00
proc resumeRead(transp: StreamTransport) {.inline.} =
transp.state.excl(ReadPaused)
addReader(transp.fd, readStreamLoop, cast[pointer](transp))
proc resumeWrite(transp: StreamTransport) {.inline.} =
transp.state.excl(WritePaused)
addWriter(transp.fd, writeStreamLoop, cast[pointer](transp))
proc start*(server: StreamServer) =
2018-05-21 21:52:57 +00:00
## Starts ``server``.
if server.status == ServerStatus.Starting:
server.resumeAccept()
server.status = ServerStatus.Running
2018-05-16 08:22:34 +00:00
proc stop*(server: StreamServer) =
2018-05-22 21:03:13 +00:00
## Stops ``server``.
if server.status == ServerStatus.Running:
server.pauseAccept()
server.status = ServerStatus.Stopped
elif server.status == ServerStatus.Starting:
server.status = ServerStatus.Stopped
2018-05-16 08:22:34 +00:00
proc join*(server: StreamServer): Future[void] =
## Waits until ``server`` is not closed.
var retFuture = newFuture[void]("stream.server.join")
proc continuation(udata: pointer) = retFuture.complete()
2018-05-21 21:52:57 +00:00
if not server.loopFuture.finished:
server.loopFuture.addCallback(continuation)
else:
retFuture.complete()
return retFuture
2018-05-21 21:52:57 +00:00
proc close*(server: StreamServer) =
2018-05-21 21:52:57 +00:00
## Release ``server`` resources.
##
## Please note that release of resources is not completed immediately, to be
## sure all resources got released please use ``await server.join()``.
proc continuation(udata: pointer) =
server.loopFuture.complete()
if not isNil(server.udata) and GCUserData in server.flags:
GC_unref(cast[ref int](server.udata))
GC_unref(server)
if server.status == ServerStatus.Stopped:
server.status = ServerStatus.Closed
when defined(windows):
if server.local.family in {AddressFamily.IPv4, AddressFamily.IPv6}:
server.sock.closeSocket(continuation)
elif server.local.family in {AddressFamily.Unix}:
if NoPipeFlash notin server.flags:
discard flushFileBuffers(Handle(server.sock))
doAssert disconnectNamedPipe(Handle(server.sock)) == 1
closeHandle(server.sock, continuation)
else:
server.sock.closeSocket(continuation)
proc closeWait*(server: StreamServer): Future[void] =
## Close server ``server`` and release all resources.
2018-09-13 18:15:57 +00:00
server.close()
result = server.join()
2018-05-16 08:22:34 +00:00
proc createStreamServer*(host: TransportAddress,
cbproc: StreamCallback,
flags: set[ServerFlags] = {},
2018-05-16 08:22:34 +00:00
sock: AsyncFD = asyncInvalidSocket,
backlog: int = 100,
bufferSize: int = DefaultStreamBufferSize,
child: StreamServer = nil,
init: TransportInitCallback = nil,
2018-05-16 08:22:34 +00:00
udata: pointer = nil): StreamServer =
2018-05-28 23:35:15 +00:00
## Create new TCP stream server.
##
## ``host`` - address to which server will be bound.
## ``flags`` - flags to apply to server socket.
## ``cbproc`` - callback function which will be called, when new client
## connection will be established.
2018-05-28 23:35:15 +00:00
## ``sock`` - user-driven socket to use.
## ``backlog`` - number of outstanding connections in the socket's listen
## queue.
## ``bufferSize`` - size of internal buffer for transport.
## ``child`` - existing object ``StreamServer``object to initialize, can be
## used to initalize ``StreamServer`` inherited objects.
2018-05-28 23:35:15 +00:00
## ``udata`` - user-defined pointer.
2018-05-16 08:22:34 +00:00
var
saddr: Sockaddr_storage
slen: SockLen
serverSocket: AsyncFD
when defined(windows):
# Windows
if host.family in {AddressFamily.IPv4, AddressFamily.IPv6}:
if sock == asyncInvalidSocket:
serverSocket = createAsyncSocket(host.getDomain(),
SockType.SOCK_STREAM,
Protocol.IPPROTO_TCP)
if serverSocket == asyncInvalidSocket:
raiseTransportOsError(osLastError())
else:
if not setSocketBlocking(SocketHandle(sock), false):
raiseTransportOsError(osLastError())
register(sock)
serverSocket = sock
# SO_REUSEADDR is not useful for Unix domain sockets.
if ServerFlags.ReuseAddr in flags:
if not setSockOpt(serverSocket, SOL_SOCKET, SO_REUSEADDR, 1):
let err = osLastError()
if sock == asyncInvalidSocket:
serverSocket.closeSocket()
raiseTransportOsError(err)
# TCP flags are not useful for Unix domain sockets.
if ServerFlags.TcpNoDelay in flags:
if not setSockOpt(serverSocket, handles.IPPROTO_TCP,
handles.TCP_NODELAY, 1):
let err = osLastError()
if sock == asyncInvalidSocket:
serverSocket.closeSocket()
raiseTransportOsError(err)
host.toSAddr(saddr, slen)
if bindAddr(SocketHandle(serverSocket), cast[ptr SockAddr](addr saddr),
slen) != 0:
let err = osLastError()
if sock == asyncInvalidSocket:
serverSocket.closeSocket()
raiseTransportOsError(err)
if nativesockets.listen(SocketHandle(serverSocket), cint(backlog)) != 0:
let err = osLastError()
if sock == asyncInvalidSocket:
serverSocket.closeSocket()
raiseTransportOsError(err)
elif host.family == AddressFamily.Unix:
serverSocket = AsyncFD(0)
else:
# Posix
if sock == asyncInvalidSocket:
var proto = Protocol.IPPROTO_TCP
if host.family == AddressFamily.Unix:
# `Protocol` enum is missing `0` value, so we making here cast, until
# `Protocol` enum will not support IPPROTO_IP == 0.
proto = cast[Protocol](0)
serverSocket = createAsyncSocket(host.getDomain(),
SockType.SOCK_STREAM,
proto)
if serverSocket == asyncInvalidSocket:
raiseTransportOsError(osLastError())
else:
if not setSocketBlocking(SocketHandle(sock), false):
raiseTransportOsError(osLastError())
register(sock)
serverSocket = sock
if host.family in {AddressFamily.IPv4, AddressFamily.IPv6}:
# SO_REUSEADDR is not useful for Unix domain sockets.
if ServerFlags.ReuseAddr in flags:
if not setSockOpt(serverSocket, SOL_SOCKET, SO_REUSEADDR, 1):
let err = osLastError()
if sock == asyncInvalidSocket:
serverSocket.closeSocket()
raiseTransportOsError(err)
# TCP flags are not useful for Unix domain sockets.
if ServerFlags.TcpNoDelay in flags:
if not setSockOpt(serverSocket, handles.IPPROTO_TCP,
handles.TCP_NODELAY, 1):
let err = osLastError()
if sock == asyncInvalidSocket:
serverSocket.closeSocket()
raiseTransportOsError(err)
elif host.family in {AddressFamily.Unix}:
# We do not care about result here, because if file cannot be removed,
# `bindAddr` will return EADDRINUSE.
discard posix.unlink(cast[cstring](unsafeAddr host.address_un[0]))
host.toSAddr(saddr, slen)
if bindAddr(SocketHandle(serverSocket), cast[ptr SockAddr](addr saddr),
slen) != 0:
2018-05-16 08:22:34 +00:00
let err = osLastError()
if sock == asyncInvalidSocket:
serverSocket.closeSocket()
raiseTransportOsError(err)
2018-05-16 08:22:34 +00:00
if nativesockets.listen(SocketHandle(serverSocket), cint(backlog)) != 0:
let err = osLastError()
if sock == asyncInvalidSocket:
serverSocket.closeSocket()
raiseTransportOsError(err)
if not isNil(child):
result = child
else:
result = StreamServer()
2018-05-16 08:22:34 +00:00
result.sock = serverSocket
result.flags = flags
2018-05-16 08:22:34 +00:00
result.function = cbproc
result.init = init
2018-05-16 08:22:34 +00:00
result.bufferSize = bufferSize
result.status = Starting
result.loopFuture = newFuture[void]("stream.server")
2018-05-16 08:22:34 +00:00
result.udata = udata
result.local = host
when defined(windows):
var cb: CallbackFunc
if host.family in {AddressFamily.IPv4, AddressFamily.IPv6}:
cb = acceptLoop
elif host.family == AddressFamily.Unix:
cb = acceptPipeLoop
result.aovl.data = CompletionData(fd: serverSocket, cb: cb,
udata: cast[pointer](result))
result.domain = host.getDomain()
result.apending = false
2018-05-21 21:52:57 +00:00
GC_ref(result)
2018-05-16 08:22:34 +00:00
proc createStreamServer*[T](host: TransportAddress,
cbproc: StreamCallback,
flags: set[ServerFlags] = {},
udata: ref T,
sock: AsyncFD = asyncInvalidSocket,
backlog: int = 100,
bufferSize: int = DefaultStreamBufferSize,
child: StreamServer = nil,
init: TransportInitCallback = nil): StreamServer =
var fflags = flags + {GCUserData}
GC_ref(udata)
result = createStreamServer(host, cbproc, flags, sock, backlog, bufferSize,
child, init, cast[pointer](udata))
proc getUserData*[T](server: StreamServer): T {.inline.} =
## Obtain user data stored in ``server`` object.
result = cast[T](server.udata)
2018-05-16 08:22:34 +00:00
proc write*(transp: StreamTransport, pbytes: pointer,
nbytes: int): Future[int] =
## Write data from buffer ``pbytes`` with size ``nbytes`` using transport
2018-05-22 21:03:13 +00:00
## ``transp``.
var retFuture = newFuture[int]()
transp.checkClosed(retFuture)
var vector = StreamVector(kind: DataBuffer, writer: retFuture,
2018-05-21 21:52:57 +00:00
buf: pbytes, buflen: nbytes)
2018-05-16 08:22:34 +00:00
transp.queue.addLast(vector)
if WritePaused in transp.state:
transp.resumeWrite()
return retFuture
2018-06-15 12:09:44 +00:00
proc write*(transp: StreamTransport, msg: string, msglen = -1): Future[int] =
## Write data from string ``msg`` using transport ``transp``.
var retFuture = FutureGCString[int]()
transp.checkClosed(retFuture)
2018-06-15 12:09:44 +00:00
if not isLiteral(msg):
shallowCopy(retFuture.gcholder, msg)
else:
retFuture.gcholder = msg
2018-06-15 12:09:44 +00:00
let length = if msglen <= 0: len(msg) else: msglen
var vector = StreamVector(kind: DataBuffer,
writer: cast[Future[int]](retFuture),
2018-06-15 12:09:44 +00:00
buf: addr retFuture.gcholder[0], buflen: length)
transp.queue.addLast(vector)
if WritePaused in transp.state:
transp.resumeWrite()
return retFuture
2018-06-15 12:09:44 +00:00
proc write*[T](transp: StreamTransport, msg: seq[T], msglen = -1): Future[int] =
## Write sequence ``msg`` using transport ``transp``.
var retFuture = FutureGCSeq[int, T]()
transp.checkClosed(retFuture)
2018-06-15 12:09:44 +00:00
if not isLiteral(msg):
shallowCopy(retFuture.gcholder, msg)
else:
retFuture.gcholder = msg
2018-06-15 12:09:44 +00:00
let length = if msglen <= 0: (len(msg) * sizeof(T)) else: (msglen * sizeof(T))
var vector = StreamVector(kind: DataBuffer,
writer: cast[Future[int]](retFuture),
2018-06-15 12:09:44 +00:00
buf: addr retFuture.gcholder[0],
buflen: length)
transp.queue.addLast(vector)
if WritePaused in transp.state:
transp.resumeWrite()
return retFuture
2018-05-21 21:52:57 +00:00
proc writeFile*(transp: StreamTransport, handle: int,
offset: uint = 0, size: int = 0): Future[int] =
2018-05-22 21:03:13 +00:00
## Write data from file descriptor ``handle`` to transport ``transp``.
##
2018-05-22 21:03:13 +00:00
## You can specify starting ``offset`` in opened file and number of bytes
## to transfer from file to transport via ``size``.
when defined(windows):
if transp.kind != TransportKind.Socket:
raise newException(TransportNoSupport, "writeFile() is not supported!")
var retFuture = newFuture[int]("transport.writeFile")
transp.checkClosed(retFuture)
var vector = StreamVector(kind: DataFile, writer: retFuture,
2018-05-21 21:52:57 +00:00
buf: cast[pointer](size), offset: offset,
buflen: handle)
transp.queue.addLast(vector)
if WritePaused in transp.state:
transp.resumeWrite()
return retFuture
2018-05-16 08:22:34 +00:00
proc atEof*(transp: StreamTransport): bool {.inline.} =
## Returns ``true`` if ``transp`` is at EOF.
result = (transp.offset == 0) and (ReadEof in transp.state) and
(ReadPaused in transp.state)
2018-05-16 08:22:34 +00:00
proc readExactly*(transp: StreamTransport, pbytes: pointer,
2018-05-21 21:52:57 +00:00
nbytes: int) {.async.} =
2018-05-22 21:03:13 +00:00
## Read exactly ``nbytes`` bytes from transport ``transp`` and store it to
## ``pbytes``.
##
2018-05-22 21:03:13 +00:00
## If EOF is received and ``nbytes`` is not yet readed, the procedure
## will raise ``TransportIncompleteError``.
2018-05-16 08:22:34 +00:00
checkClosed(transp)
checkPending(transp)
2018-07-24 15:43:30 +00:00
2018-05-16 08:22:34 +00:00
var index = 0
while true:
if transp.offset == 0:
if (ReadError in transp.state):
raise transp.getError()
if (ReadClosed in transp.state) or transp.atEof():
2018-05-16 08:22:34 +00:00
raise newException(TransportIncompleteError, "Data incomplete!")
if transp.offset >= (nbytes - index):
copyMem(cast[pointer](cast[uint](pbytes) + uint(index)),
addr(transp.buffer[0]), nbytes - index)
transp.shiftBuffer(nbytes - index)
break
else:
2018-05-21 21:52:57 +00:00
if transp.offset != 0:
copyMem(cast[pointer](cast[uint](pbytes) + uint(index)),
addr(transp.buffer[0]), transp.offset)
index += transp.offset
2018-07-25 04:05:52 +00:00
var fut = newFuture[void]("stream.transport.readExactly")
transp.reader = fut
2018-05-16 08:22:34 +00:00
transp.offset = 0
if ReadPaused in transp.state:
transp.resumeRead()
2018-07-25 04:05:52 +00:00
await fut
2018-05-16 08:22:34 +00:00
proc readOnce*(transp: StreamTransport, pbytes: pointer,
nbytes: int): Future[int] {.async.} =
## Perform one read operation on transport ``transp``.
##
## If internal buffer is not empty, ``nbytes`` bytes will be transferred from
## internal buffer, otherwise it will wait until some bytes will be received.
2018-05-16 08:22:34 +00:00
checkClosed(transp)
checkPending(transp)
while true:
if transp.offset == 0:
if (ReadError in transp.state):
raise transp.getError()
if (ReadClosed in transp.state) or transp.atEof():
2018-05-16 08:22:34 +00:00
result = 0
break
2018-07-25 04:05:52 +00:00
var fut = newFuture[void]("stream.transport.readOnce")
transp.reader = fut
2018-05-16 08:22:34 +00:00
if ReadPaused in transp.state:
transp.resumeRead()
2018-07-25 04:05:52 +00:00
await fut
2018-05-16 08:22:34 +00:00
else:
if transp.offset > nbytes:
copyMem(pbytes, addr(transp.buffer[0]), nbytes)
transp.shiftBuffer(nbytes)
result = nbytes
else:
copyMem(pbytes, addr(transp.buffer[0]), transp.offset)
result = transp.offset
break
proc readUntil*(transp: StreamTransport, pbytes: pointer, nbytes: int,
sep: seq[byte]): Future[int] {.async.} =
2018-05-22 21:03:13 +00:00
## Read data from the transport ``transp`` until separator ``sep`` is found.
##
2018-05-22 21:03:13 +00:00
## On success, the data and separator will be removed from the internal
## buffer (consumed). Returned data will NOT include the separator at the end.
##
2018-05-28 23:35:15 +00:00
## If EOF is received, and `sep` was not found, procedure will raise
## ``TransportIncompleteError``.
##
2018-05-28 23:35:15 +00:00
## If ``nbytes`` bytes has been received and `sep` was not found, procedure
## will raise ``TransportLimitError``.
##
2018-05-28 23:35:15 +00:00
## Procedure returns actual number of bytes read.
2018-05-16 08:22:34 +00:00
checkClosed(transp)
checkPending(transp)
var dest = cast[ptr UncheckedArray[byte]](pbytes)
var state = 0
var k = 0
var index = 0
while true:
if ReadError in transp.state:
raise transp.getError()
if (ReadClosed in transp.state) or transp.atEof():
raise newException(TransportIncompleteError, "Data incomplete!")
2018-05-16 08:22:34 +00:00
index = 0
while index < transp.offset:
let ch = transp.buffer[index]
if sep[state] == ch:
inc(state)
else:
state = 0
if k < nbytes:
dest[k] = ch
inc(k)
else:
raise newException(TransportLimitError, "Limit reached!")
if state == len(sep):
break
inc(index)
if state == len(sep):
transp.shiftBuffer(index + 1)
2018-05-16 08:22:34 +00:00
result = k
break
else:
transp.shiftBuffer(transp.offset)
2018-07-25 04:05:52 +00:00
var fut = newFuture[void]("stream.transport.readUntil")
transp.reader = fut
if ReadPaused in transp.state:
transp.resumeRead()
2018-07-25 04:05:52 +00:00
await fut
2018-05-16 08:22:34 +00:00
proc readLine*(transp: StreamTransport, limit = 0,
sep = "\r\n"): Future[string] {.async.} =
2018-05-22 21:03:13 +00:00
## Read one line from transport ``transp``, where "line" is a sequence of
## bytes ending with ``sep`` (default is "\r\n").
##
2018-05-22 21:03:13 +00:00
## If EOF is received, and ``sep`` was not found, the method will return the
## partial read bytes.
##
2018-05-22 21:03:13 +00:00
## If the EOF was received and the internal buffer is empty, return an
## empty string.
##
2018-05-22 21:03:13 +00:00
## If ``limit`` more then 0, then read is limited to ``limit`` bytes.
2018-05-16 08:22:34 +00:00
checkClosed(transp)
checkPending(transp)
result = ""
var lim = if limit <= 0: -1 else: limit
var state = 0
var index = 0
while true:
if (ReadError in transp.state):
raise transp.getError()
if (ReadClosed in transp.state) or transp.atEof():
break
2018-05-16 08:22:34 +00:00
index = 0
while index < transp.offset:
let ch = char(transp.buffer[index])
if sep[state] == ch:
inc(state)
if state == len(sep):
transp.shiftBuffer(index + 1)
break
else:
state = 0
result.add(ch)
if len(result) == lim:
transp.shiftBuffer(index + 1)
break
inc(index)
if (state == len(sep)) or (lim == len(result)):
break
else:
transp.shiftBuffer(transp.offset)
2018-07-25 04:05:52 +00:00
var fut = newFuture[void]("stream.transport.readLine")
transp.reader = fut
if ReadPaused in transp.state:
transp.resumeRead()
2018-07-25 04:05:52 +00:00
await fut
2018-05-16 08:22:34 +00:00
proc read*(transp: StreamTransport, n = -1): Future[seq[byte]] {.async.} =
## Read all bytes (n == -1) or exactly `n` bytes from transport ``transp``.
##
2018-05-28 23:35:15 +00:00
## This procedure allocates buffer seq[byte] and return it as result.
2018-05-16 08:22:34 +00:00
checkClosed(transp)
checkPending(transp)
result = newSeq[byte]()
while true:
if (ReadError in transp.state):
raise transp.getError()
if (ReadClosed in transp.state) or transp.atEof():
2018-05-16 08:22:34 +00:00
break
2018-05-16 08:22:34 +00:00
if transp.offset > 0:
let s = len(result)
let o = s + transp.offset
if n < 0:
2018-05-16 08:22:34 +00:00
# grabbing all incoming data, until EOF
result.setLen(o)
copyMem(cast[pointer](addr result[s]), addr(transp.buffer[0]),
transp.offset)
transp.offset = 0
else:
let left = n - s
if transp.offset >= left:
2018-05-16 08:22:34 +00:00
# size of buffer data is more then we need, grabbing only part
result.setLen(n)
copyMem(cast[pointer](addr result[s]), addr(transp.buffer[0]),
left)
transp.shiftBuffer(left)
2018-05-16 08:22:34 +00:00
break
else:
# there not enough data in buffer, grabbing all
result.setLen(o)
copyMem(cast[pointer](addr result[s]), addr(transp.buffer[0]),
transp.offset)
transp.offset = 0
2018-07-25 04:05:52 +00:00
var fut = newFuture[void]("stream.transport.read")
transp.reader = fut
2018-05-16 08:22:34 +00:00
if ReadPaused in transp.state:
transp.resumeRead()
2018-07-25 04:05:52 +00:00
await fut
2018-05-16 08:22:34 +00:00
proc consume*(transp: StreamTransport, n = -1): Future[int] {.async.} =
## Consume all bytes (n == -1) or ``n`` bytes from transport ``transp``.
##
## Return number of bytes actually consumed
checkClosed(transp)
checkPending(transp)
result = 0
while true:
if (ReadError in transp.state):
raise transp.getError()
if ReadClosed in transp.state or transp.atEof():
break
if transp.offset > 0:
if n == -1:
# consume all incoming data, until EOF
result += transp.offset
transp.offset = 0
else:
let left = n - result
if transp.offset >= left:
# size of buffer data is more then we need, consume only part
result += left
transp.shiftBuffer(left)
break
else:
# there not enough data in buffer, consume all
result += transp.offset
transp.offset = 0
2018-07-25 04:05:52 +00:00
var fut = newFuture[void]("stream.transport.consume")
transp.reader = fut
if ReadPaused in transp.state:
transp.resumeRead()
2018-07-25 04:05:52 +00:00
await fut
2018-05-16 08:22:34 +00:00
proc join*(transp: StreamTransport): Future[void] =
2018-05-16 08:22:34 +00:00
## Wait until ``transp`` will not be closed.
var retFuture = newFuture[void]("streamtransport.join")
proc continuation(udata: pointer) = retFuture.complete()
2018-05-21 21:52:57 +00:00
if not transp.future.finished:
transp.future.addCallback(continuation)
else:
retFuture.complete()
return retFuture
2018-05-16 08:22:34 +00:00
proc close*(transp: StreamTransport) =
## Closes and frees resources of transport ``transp``.
##
## Please note that release of resources is not completed immediately, to be
## sure all resources got released please use ``await transp.join()``.
proc continuation(udata: pointer) =
transp.future.complete()
GC_unref(transp)
if {ReadClosed, WriteClosed} * transp.state == {}:
transp.state.incl({WriteClosed, ReadClosed})
2018-05-16 08:22:34 +00:00
when defined(windows):
discard cancelIo(Handle(transp.fd))
if transp.kind == TransportKind.Pipe:
if WinServerPipe in transp.flags:
if WinNoPipeFlash notin transp.flags:
discard flushFileBuffers(Handle(transp.fd))
doAssert disconnectNamedPipe(Handle(transp.fd)) == 1
else:
if WinNoPipeFlash notin transp.flags:
discard flushFileBuffers(Handle(transp.fd))
closeHandle(transp.fd, continuation)
elif transp.kind == TransportKind.Socket:
closeSocket(transp.fd, continuation)
else:
closeSocket(transp.fd, continuation)
proc closeWait*(transp: StreamTransport): Future[void] =
## Close and frees resources of transport ``transp``.
2018-09-13 18:15:57 +00:00
transp.close()
result = transp.join()
proc closed*(transp: StreamTransport): bool {.inline.} =
## Returns ``true`` if transport in closed state.
result = ({ReadClosed, WriteClosed} * transp.state != {})