2018-05-16 08:22:34 +00:00
|
|
|
#
|
2019-02-06 14:49:11 +00:00
|
|
|
# Chronos Transport Common Types
|
|
|
|
# (c) Copyright 2018-Present
|
2018-05-16 08:22:34 +00:00
|
|
|
# Status Research & Development GmbH
|
|
|
|
#
|
|
|
|
# Licensed under either of
|
|
|
|
# Apache License, version 2.0, (LICENSE-APACHEv2)
|
|
|
|
# MIT license (LICENSE-MIT)
|
2018-10-27 14:19:58 +00:00
|
|
|
import os, strutils, nativesockets, net
|
2018-06-05 20:21:07 +00:00
|
|
|
import ../asyncloop
|
2018-10-27 14:19:58 +00:00
|
|
|
export net
|
2018-06-07 06:17:59 +00:00
|
|
|
|
2018-06-10 00:55:19 +00:00
|
|
|
when defined(windows):
|
|
|
|
import winlean
|
|
|
|
else:
|
|
|
|
import posix
|
|
|
|
|
2018-05-16 08:22:34 +00:00
|
|
|
const
|
|
|
|
DefaultStreamBufferSize* = 4096 ## Default buffer size for stream
|
|
|
|
## transports
|
|
|
|
DefaultDatagramBufferSize* = 65536 ## Default buffer size for datagram
|
|
|
|
## transports
|
|
|
|
type
|
|
|
|
ServerFlags* = enum
|
|
|
|
## Server's flags
|
2018-10-25 10:19:19 +00:00
|
|
|
ReuseAddr, ReusePort, TcpNoDelay, NoAutoRead, GCUserData, FirstPipe,
|
2019-03-30 22:31:10 +00:00
|
|
|
NoPipeFlash, Broadcast
|
2018-10-25 10:19:19 +00:00
|
|
|
|
|
|
|
AddressFamily* {.pure.} = enum
|
|
|
|
None, IPv4, IPv6, Unix
|
2018-05-16 08:22:34 +00:00
|
|
|
|
|
|
|
TransportAddress* = object
|
|
|
|
## Transport network address
|
2018-10-25 10:19:19 +00:00
|
|
|
case family*: AddressFamily
|
|
|
|
of AddressFamily.None:
|
|
|
|
discard
|
|
|
|
of AddressFamily.IPv4:
|
|
|
|
address_v4*: array[4, uint8]
|
|
|
|
of AddressFamily.IPv6:
|
|
|
|
address_v6*: array[16, uint8]
|
|
|
|
of AddressFamily.Unix:
|
|
|
|
address_un*: array[108, uint8]
|
|
|
|
port*: Port # Port number
|
2018-05-16 08:22:34 +00:00
|
|
|
|
|
|
|
ServerCommand* = enum
|
|
|
|
## Server's commands
|
|
|
|
Start, # Start server
|
|
|
|
Pause, # Pause server
|
|
|
|
Stop # Stop server
|
|
|
|
|
|
|
|
ServerStatus* = enum
|
|
|
|
## Server's statuses
|
|
|
|
Starting, # Server created
|
|
|
|
Stopped, # Server stopped
|
|
|
|
Running, # Server running
|
2018-06-04 09:57:17 +00:00
|
|
|
Closed # Server closed
|
2018-05-16 08:22:34 +00:00
|
|
|
|
2018-06-04 09:57:17 +00:00
|
|
|
when defined(windows):
|
|
|
|
type
|
|
|
|
SocketServer* = ref object of RootRef
|
|
|
|
## Socket server object
|
|
|
|
sock*: AsyncFD # Socket
|
|
|
|
local*: TransportAddress # Address
|
|
|
|
status*: ServerStatus # Current server status
|
|
|
|
udata*: pointer # User-defined pointer
|
|
|
|
flags*: set[ServerFlags] # Flags
|
|
|
|
bufferSize*: int # Size of internal transports' buffer
|
|
|
|
loopFuture*: Future[void] # Server's main Future
|
|
|
|
domain*: Domain # Current server domain (IPv4 or IPv6)
|
|
|
|
apending*: bool
|
|
|
|
asock*: AsyncFD # Current AcceptEx() socket
|
2020-06-24 08:21:52 +00:00
|
|
|
errorCode*: OSErrorCode # Current error code
|
2018-06-04 09:57:17 +00:00
|
|
|
abuffer*: array[128, byte] # Windows AcceptEx() buffer
|
|
|
|
aovl*: CustomOverlapped # AcceptEx OVERLAPPED structure
|
|
|
|
else:
|
|
|
|
type
|
|
|
|
SocketServer* = ref object of RootRef
|
|
|
|
## Socket server object
|
|
|
|
sock*: AsyncFD # Socket
|
|
|
|
local*: TransportAddress # Address
|
|
|
|
status*: ServerStatus # Current server status
|
|
|
|
udata*: pointer # User-defined pointer
|
|
|
|
flags*: set[ServerFlags] # Flags
|
|
|
|
bufferSize*: int # Size of internal transports' buffer
|
|
|
|
loopFuture*: Future[void] # Server's main Future
|
2020-06-24 08:21:52 +00:00
|
|
|
errorCode*: OSErrorCode # Current error code
|
2018-05-16 08:22:34 +00:00
|
|
|
|
2018-06-04 09:57:17 +00:00
|
|
|
type
|
2018-07-20 08:58:01 +00:00
|
|
|
TransportError* = object of AsyncError
|
2018-05-16 08:22:34 +00:00
|
|
|
## Transport's specific exception
|
|
|
|
TransportOsError* = object of TransportError
|
|
|
|
## Transport's OS specific exception
|
2018-10-03 00:44:39 +00:00
|
|
|
code*: OSErrorCode
|
2018-05-16 08:22:34 +00:00
|
|
|
TransportIncompleteError* = object of TransportError
|
|
|
|
## Transport's `incomplete data received` exception
|
|
|
|
TransportLimitError* = object of TransportError
|
|
|
|
## Transport's `data limit reached` exception
|
2018-06-10 00:55:19 +00:00
|
|
|
TransportAddressError* = object of TransportError
|
2018-10-03 00:44:39 +00:00
|
|
|
## Transport's address specific exception
|
|
|
|
code*: OSErrorCode
|
2018-10-25 10:19:19 +00:00
|
|
|
TransportNoSupport* = object of TransportError
|
|
|
|
## Transport's capability not supported exception
|
2020-03-05 09:59:10 +00:00
|
|
|
TransportUseClosedError* = object of TransportError
|
|
|
|
## Usage after transport close exception
|
2020-06-24 08:21:52 +00:00
|
|
|
TransportTooManyError* = object of TransportError
|
|
|
|
## Too many open file descriptors exception
|
2018-05-16 08:22:34 +00:00
|
|
|
|
|
|
|
TransportState* = enum
|
|
|
|
## Transport's state
|
|
|
|
ReadPending, # Read operation pending (Windows)
|
|
|
|
ReadPaused, # Read operations paused
|
|
|
|
ReadClosed, # Read operations closed
|
|
|
|
ReadEof, # Read at EOF
|
|
|
|
ReadError, # Read error
|
|
|
|
WritePending, # Writer operation pending (Windows)
|
|
|
|
WritePaused, # Writer operations paused
|
|
|
|
WriteClosed, # Writer operations closed
|
2019-05-28 06:29:00 +00:00
|
|
|
WriteEof, # Remote peer disconnected
|
2018-05-16 08:22:34 +00:00
|
|
|
WriteError # Write error
|
|
|
|
|
|
|
|
var
|
2018-10-25 10:19:19 +00:00
|
|
|
AnyAddress* = TransportAddress(family: AddressFamily.IPv4, port: Port(0))
|
|
|
|
## Default INADDR_ANY address for IPv4
|
|
|
|
AnyAddress6* = TransportAddress(family: AddressFamily.IPv6, port: Port(0))
|
|
|
|
## Default INADDR_ANY address for IPv6
|
|
|
|
|
|
|
|
proc `==`*(lhs, rhs: TransportAddress): bool =
|
|
|
|
## Compare two transport addresses ``lhs`` and ``rhs``. Return ``true`` if
|
|
|
|
## addresses are equal.
|
|
|
|
if lhs.family != lhs.family:
|
|
|
|
return false
|
|
|
|
if lhs.family == AddressFamily.IPv4:
|
|
|
|
result = equalMem(unsafeAddr lhs.address_v4[0],
|
|
|
|
unsafeAddr rhs.address_v4[0], sizeof(lhs.address_v4)) and
|
|
|
|
(lhs.port == rhs.port)
|
|
|
|
elif lhs.family == AddressFamily.IPv6:
|
|
|
|
result = equalMem(unsafeAddr lhs.address_v6[0],
|
|
|
|
unsafeAddr rhs.address_v6[0], sizeof(lhs.address_v6)) and
|
|
|
|
(lhs.port == rhs.port)
|
|
|
|
elif lhs.family == AddressFamily.Unix:
|
|
|
|
result = equalMem(unsafeAddr lhs.address_un[0],
|
|
|
|
unsafeAddr rhs.address_un[0], sizeof(lhs.address_un))
|
2018-05-16 08:22:34 +00:00
|
|
|
|
2018-05-28 23:35:15 +00:00
|
|
|
proc getDomain*(address: TransportAddress): Domain =
|
|
|
|
## Returns OS specific Domain from TransportAddress.
|
2018-10-25 10:19:19 +00:00
|
|
|
case address.family
|
|
|
|
of AddressFamily.IPv4:
|
|
|
|
result = Domain.AF_INET
|
|
|
|
of AddressFamily.IPv6:
|
|
|
|
result = Domain.AF_INET6
|
|
|
|
of AddressFamily.Unix:
|
|
|
|
when defined(windows):
|
|
|
|
result = cast[Domain](1)
|
|
|
|
else:
|
|
|
|
result = Domain.AF_UNIX
|
|
|
|
else:
|
|
|
|
result = cast[Domain](0)
|
2018-05-28 23:35:15 +00:00
|
|
|
|
2018-05-16 08:22:34 +00:00
|
|
|
proc `$`*(address: TransportAddress): string =
|
|
|
|
## Returns string representation of ``address``.
|
2018-10-25 10:19:19 +00:00
|
|
|
case address.family
|
|
|
|
of AddressFamily.IPv4:
|
|
|
|
var a = IpAddress(
|
|
|
|
family: IpAddressFamily.IPv4,
|
|
|
|
address_v4: address.address_v4
|
|
|
|
)
|
|
|
|
result = $a
|
2018-05-16 08:22:34 +00:00
|
|
|
result.add(":")
|
2018-10-25 10:19:19 +00:00
|
|
|
result.add($int(address.port))
|
|
|
|
of AddressFamily.IPv6:
|
|
|
|
var a = IpAddress(family: IpAddressFamily.IPv6,
|
|
|
|
address_v6: address.address_v6)
|
|
|
|
result = "[" & $a & "]:"
|
|
|
|
result.add($(int(address.port)))
|
|
|
|
of AddressFamily.Unix:
|
|
|
|
const length = sizeof(address.address_un) + 1
|
|
|
|
var buffer: array[length, char]
|
|
|
|
if not equalMem(addr buffer[0], unsafeAddr address.address_un[0],
|
|
|
|
sizeof(address.address_un)):
|
|
|
|
copyMem(addr buffer[0], unsafeAddr address.address_un[0],
|
|
|
|
sizeof(address.address_un))
|
|
|
|
result = $cast[cstring](addr buffer)
|
|
|
|
else:
|
|
|
|
result = ""
|
|
|
|
else:
|
|
|
|
raise newException(TransportAddressError, "Unknown address family!")
|
2018-05-16 08:22:34 +00:00
|
|
|
|
2018-06-02 14:25:26 +00:00
|
|
|
proc initTAddress*(address: string): TransportAddress =
|
2018-10-25 10:19:19 +00:00
|
|
|
## Parses string representation of ``address``. ``address`` can be IPv4, IPv6
|
|
|
|
## or Unix domain address.
|
2018-05-29 09:59:39 +00:00
|
|
|
##
|
2018-05-21 21:52:57 +00:00
|
|
|
## IPv4 transport address format is ``a.b.c.d:port``.
|
|
|
|
## IPv6 transport address format is ``[::]:port``.
|
2018-10-25 10:19:19 +00:00
|
|
|
## Unix transport address format is ``/address``.
|
|
|
|
if len(address) > 0:
|
|
|
|
if address[0] == '/':
|
|
|
|
result = TransportAddress(family: AddressFamily.Unix, port: Port(1))
|
|
|
|
let size = if len(address) < (sizeof(result.address_un) - 1): len(address)
|
|
|
|
else: (sizeof(result.address_un) - 1)
|
|
|
|
copyMem(addr result.address_un[0], unsafeAddr address[0], size)
|
2018-06-10 00:55:19 +00:00
|
|
|
else:
|
2019-03-27 19:42:46 +00:00
|
|
|
var port: int
|
2018-10-25 10:19:19 +00:00
|
|
|
var parts = address.rsplit(":", maxsplit = 1)
|
|
|
|
if len(parts) != 2:
|
|
|
|
raise newException(TransportAddressError,
|
|
|
|
"Format is <address>:<port> or </address>!")
|
|
|
|
try:
|
2019-03-27 19:42:46 +00:00
|
|
|
port = parseInt(parts[1])
|
2018-10-25 10:19:19 +00:00
|
|
|
except:
|
|
|
|
raise newException(TransportAddressError, "Illegal port number!")
|
2019-03-27 19:42:46 +00:00
|
|
|
if port < 0 or port >= 65536:
|
|
|
|
raise newException(TransportAddressError, "Illegal port number!")
|
2018-10-25 10:19:19 +00:00
|
|
|
try:
|
|
|
|
var ipaddr: IpAddress
|
|
|
|
if parts[0][0] == '[' and parts[0][^1] == ']':
|
|
|
|
ipaddr = parseIpAddress(parts[0][1..^2])
|
|
|
|
else:
|
|
|
|
ipaddr = parseIpAddress(parts[0])
|
|
|
|
if ipaddr.family == IpAddressFamily.IPv4:
|
|
|
|
result = TransportAddress(family: AddressFamily.IPv4)
|
|
|
|
result.address_v4 = ipaddr.address_v4
|
|
|
|
elif ipaddr.family == IpAddressFamily.IPv6:
|
|
|
|
result = TransportAddress(family: AddressFamily.IPv6)
|
|
|
|
result.address_v6 = ipaddr.address_v6
|
|
|
|
else:
|
|
|
|
raise newException(TransportAddressError, "Incorrect address family!")
|
2019-03-27 19:42:46 +00:00
|
|
|
result.port = Port(port)
|
2019-11-28 18:14:19 +00:00
|
|
|
except CatchableError as exc:
|
|
|
|
raise newException(TransportAddressError, exc.msg)
|
2018-10-25 10:19:19 +00:00
|
|
|
else:
|
|
|
|
result = TransportAddress(family: AddressFamily.Unix)
|
2018-05-16 08:22:34 +00:00
|
|
|
|
2018-06-02 14:25:26 +00:00
|
|
|
proc initTAddress*(address: string, port: Port): TransportAddress =
|
2018-10-25 10:19:19 +00:00
|
|
|
## Initialize ``TransportAddress`` with IP (IPv4 or IPv6) address ``address``
|
|
|
|
## and port number ``port``.
|
2018-06-10 00:55:19 +00:00
|
|
|
try:
|
2018-10-25 10:19:19 +00:00
|
|
|
var ipaddr = parseIpAddress(address)
|
|
|
|
if ipaddr.family == IpAddressFamily.IPv4:
|
|
|
|
result = TransportAddress(family: AddressFamily.IPv4, port: port)
|
|
|
|
result.address_v4 = ipaddr.address_v4
|
|
|
|
elif ipaddr.family == IpAddressFamily.IPv6:
|
|
|
|
result = TransportAddress(family: AddressFamily.IPv6, port: port)
|
|
|
|
result.address_v6 = ipaddr.address_v6
|
|
|
|
else:
|
|
|
|
raise newException(TransportAddressError, "Incorrect address family!")
|
2019-11-28 18:14:19 +00:00
|
|
|
except CatchableError as exc:
|
|
|
|
raise newException(TransportAddressError, exc.msg)
|
2018-06-02 14:25:26 +00:00
|
|
|
|
2018-10-25 10:19:19 +00:00
|
|
|
proc initTAddress*(address: string, port: int): TransportAddress {.inline.} =
|
|
|
|
## Initialize ``TransportAddress`` with IP (IPv4 or IPv6) address ``address``
|
|
|
|
## and port number ``port``.
|
2018-06-10 00:55:19 +00:00
|
|
|
if port < 0 or port >= 65536:
|
|
|
|
raise newException(TransportAddressError, "Illegal port number!")
|
2018-10-25 10:19:19 +00:00
|
|
|
else:
|
|
|
|
result = initTAddress(address, Port(port))
|
2018-06-10 00:55:19 +00:00
|
|
|
|
2018-06-14 07:15:31 +00:00
|
|
|
proc initTAddress*(address: IpAddress, port: Port): TransportAddress =
|
|
|
|
## Initialize ``TransportAddress`` with net.nim ``IpAddress`` and
|
|
|
|
## port number ``port``.
|
2020-05-15 11:09:21 +00:00
|
|
|
case address.family
|
|
|
|
of IpAddressFamily.IPv4:
|
2018-10-25 10:19:19 +00:00
|
|
|
result = TransportAddress(family: AddressFamily.IPv4, port: port)
|
|
|
|
result.address_v4 = address.address_v4
|
2020-05-15 11:09:21 +00:00
|
|
|
of IpAddressFamily.IPv6:
|
2018-10-25 10:19:19 +00:00
|
|
|
result = TransportAddress(family: AddressFamily.IPv6, port: port)
|
|
|
|
result.address_v6 = address.address_v6
|
2018-06-14 07:15:31 +00:00
|
|
|
|
2018-06-10 00:55:19 +00:00
|
|
|
proc getAddrInfo(address: string, port: Port, domain: Domain,
|
|
|
|
sockType: SockType = SockType.SOCK_STREAM,
|
|
|
|
protocol: Protocol = Protocol.IPPROTO_TCP): ptr AddrInfo =
|
|
|
|
## We have this one copy of ``getAddrInfo()`` because of AI_V4MAPPED in
|
|
|
|
## ``net.nim:getAddrInfo()``, which is not cross-platform.
|
|
|
|
var hints: AddrInfo
|
|
|
|
result = nil
|
|
|
|
hints.ai_family = toInt(domain)
|
|
|
|
hints.ai_socktype = toInt(sockType)
|
|
|
|
hints.ai_protocol = toInt(protocol)
|
|
|
|
var gaiResult = getaddrinfo(address, $port, addr(hints), result)
|
|
|
|
if gaiResult != 0'i32:
|
|
|
|
when defined(windows):
|
|
|
|
raise newException(TransportAddressError, osErrorMsg(osLastError()))
|
|
|
|
else:
|
|
|
|
raise newException(TransportAddressError, $gai_strerror(gaiResult))
|
2018-06-02 14:25:26 +00:00
|
|
|
|
2018-10-25 10:19:19 +00:00
|
|
|
proc fromSAddr*(sa: ptr Sockaddr_storage, sl: Socklen,
|
|
|
|
address: var TransportAddress) =
|
|
|
|
## Set transport address ``address`` with value from OS specific socket
|
|
|
|
## address storage.
|
|
|
|
if int(sa.ss_family) == toInt(Domain.AF_INET) and
|
|
|
|
int(sl) == sizeof(Sockaddr_in):
|
|
|
|
address = TransportAddress(family: AddressFamily.IPv4)
|
|
|
|
let s = cast[ptr Sockaddr_in](sa)
|
|
|
|
copyMem(addr address.address_v4[0], addr s.sin_addr,
|
|
|
|
sizeof(address.address_v4))
|
|
|
|
address.port = Port(nativesockets.ntohs(s.sin_port))
|
|
|
|
elif int(sa.ss_family) == toInt(Domain.AF_INET6) and
|
|
|
|
int(sl) == sizeof(Sockaddr_in6):
|
|
|
|
address = TransportAddress(family: AddressFamily.IPv6)
|
|
|
|
let s = cast[ptr Sockaddr_in6](sa)
|
|
|
|
copyMem(addr address.address_v6[0], addr s.sin6_addr,
|
|
|
|
sizeof(address.address_v6))
|
|
|
|
address.port = Port(nativesockets.ntohs(s.sin6_port))
|
|
|
|
elif int(sa.ss_family) == toInt(Domain.AF_UNIX):
|
|
|
|
when not defined(windows):
|
|
|
|
address = TransportAddress(family: AddressFamily.Unix)
|
|
|
|
if int(sl) > sizeof(sa.ss_family):
|
|
|
|
var length = int(sl) - sizeof(sa.ss_family)
|
|
|
|
if length > (sizeof(address.address_un) - 1):
|
|
|
|
length = sizeof(address.address_un) - 1
|
|
|
|
let s = cast[ptr Sockaddr_un](sa)
|
|
|
|
copyMem(addr address.address_un[0], addr s.sun_path[0], length)
|
|
|
|
address.port = Port(1)
|
|
|
|
else:
|
|
|
|
discard
|
|
|
|
|
|
|
|
proc toSAddr*(address: TransportAddress, sa: var Sockaddr_storage,
|
|
|
|
sl: var Socklen) =
|
|
|
|
## Set socket OS specific socket address storage with address from transport
|
|
|
|
## address ``address``.
|
|
|
|
case address.family
|
|
|
|
of AddressFamily.IPv4:
|
|
|
|
sl = Socklen(sizeof(Sockaddr_in))
|
|
|
|
let s = cast[ptr Sockaddr_in](addr sa)
|
|
|
|
s.sin_family = type(s.sin_family)(toInt(Domain.AF_INET))
|
|
|
|
s.sin_port = nativesockets.htons(uint16(address.port))
|
|
|
|
copyMem(addr s.sin_addr, unsafeAddr address.address_v4[0],
|
|
|
|
sizeof(s.sin_addr))
|
|
|
|
of AddressFamily.IPv6:
|
|
|
|
sl = Socklen(sizeof(Sockaddr_in6))
|
|
|
|
let s = cast[ptr Sockaddr_in6](addr sa)
|
|
|
|
s.sin6_family = type(s.sin6_family)(toInt(Domain.AF_INET6))
|
|
|
|
s.sin6_port = nativesockets.htons(uint16(address.port))
|
|
|
|
copyMem(addr s.sin6_addr, unsafeAddr address.address_v6[0],
|
|
|
|
sizeof(s.sin6_addr))
|
|
|
|
of AddressFamily.Unix:
|
|
|
|
when not defined(windows):
|
|
|
|
if address.port == Port(0):
|
|
|
|
sl = Socklen(sizeof(sa.ss_family))
|
|
|
|
else:
|
|
|
|
let s = cast[ptr Sockaddr_un](addr sa)
|
|
|
|
var name = cast[cstring](unsafeAddr address.address_un[0])
|
|
|
|
sl = Socklen(sizeof(sa.ss_family) + len(name) + 1)
|
|
|
|
s.sun_family = type(s.sun_family)(toInt(Domain.AF_UNIX))
|
|
|
|
copyMem(addr s.sun_path, unsafeAddr address.address_un[0],
|
|
|
|
len(name) + 1)
|
|
|
|
else:
|
|
|
|
discard
|
|
|
|
|
2018-10-27 14:19:58 +00:00
|
|
|
proc address*(ta: TransportAddress): IpAddress =
|
|
|
|
## Converts ``TransportAddress`` to ``net.IpAddress`` object.
|
2019-02-06 14:49:11 +00:00
|
|
|
##
|
2018-10-27 14:19:58 +00:00
|
|
|
## Note its impossible to convert ``TransportAddress`` of ``Unix`` family,
|
|
|
|
## because ``IpAddress`` supports only IPv4, IPv6 addresses.
|
|
|
|
if ta.family == AddressFamily.IPv4:
|
|
|
|
result = IpAddress(family: IpAddressFamily.IPv4)
|
|
|
|
result.address_v4 = ta.address_v4
|
|
|
|
elif ta.family == AddressFamily.IPv6:
|
|
|
|
result = IpAddress(family: IpAddressFamily.IPv6)
|
|
|
|
result.address_v6 = ta.address_v6
|
|
|
|
else:
|
|
|
|
raise newException(ValueError, "IpAddress supports only IPv4/IPv6!")
|
|
|
|
|
2018-06-02 14:25:26 +00:00
|
|
|
proc resolveTAddress*(address: string,
|
2018-10-25 10:19:19 +00:00
|
|
|
family = AddressFamily.IPv4): seq[TransportAddress] =
|
2018-06-02 14:25:26 +00:00
|
|
|
## Resolve string representation of ``address``.
|
2018-06-05 22:48:03 +00:00
|
|
|
##
|
2018-06-02 14:25:26 +00:00
|
|
|
## Supported formats are:
|
|
|
|
## IPv4 numeric address ``a.b.c.d:port``
|
|
|
|
## IPv6 numeric address ``[::]:port``
|
|
|
|
## Hostname address ``hostname:port``
|
2018-06-05 22:48:03 +00:00
|
|
|
##
|
2018-06-02 14:25:26 +00:00
|
|
|
## If hostname address is detected, then network address translation via DNS
|
|
|
|
## will be performed.
|
2018-06-10 00:55:19 +00:00
|
|
|
var
|
|
|
|
hostname: string
|
|
|
|
port: int
|
|
|
|
|
2018-10-25 10:19:19 +00:00
|
|
|
doAssert(family in {AddressFamily.IPv4, AddressFamily.IPv6})
|
|
|
|
|
2018-06-02 14:25:26 +00:00
|
|
|
result = newSeq[TransportAddress]()
|
|
|
|
var parts = address.rsplit(":", maxsplit = 1)
|
2018-06-10 00:55:19 +00:00
|
|
|
if len(parts) != 2:
|
|
|
|
raise newException(TransportAddressError, "Format is <address>:<port>!")
|
|
|
|
|
|
|
|
try:
|
|
|
|
port = parseInt(parts[1])
|
|
|
|
except:
|
|
|
|
raise newException(TransportAddressError, "Illegal port number!")
|
|
|
|
|
2019-03-27 19:42:46 +00:00
|
|
|
if port < 0 or port >= 65536:
|
|
|
|
raise newException(TransportAddressError, "Illegal port number!")
|
|
|
|
|
2018-06-02 14:25:26 +00:00
|
|
|
if parts[0][0] == '[' and parts[0][^1] == ']':
|
2018-06-10 00:55:19 +00:00
|
|
|
# IPv6 numeric addresses must be enclosed with `[]`.
|
|
|
|
hostname = parts[0][1..^2]
|
2018-06-02 14:25:26 +00:00
|
|
|
else:
|
2018-06-10 00:55:19 +00:00
|
|
|
hostname = parts[0]
|
|
|
|
|
2018-10-25 10:19:19 +00:00
|
|
|
var domain = if family == AddressFamily.IPv4: Domain.AF_INET else:
|
2018-06-10 00:55:19 +00:00
|
|
|
Domain.AF_INET6
|
|
|
|
var aiList = getAddrInfo(hostname, Port(port), domain)
|
|
|
|
var it = aiList
|
|
|
|
while it != nil:
|
|
|
|
var ta: TransportAddress
|
2018-10-25 10:19:19 +00:00
|
|
|
fromSAddr(cast[ptr Sockaddr_storage](it.ai_addr),
|
|
|
|
SockLen(it.ai_addrlen), ta)
|
2018-06-10 00:55:19 +00:00
|
|
|
# For some reason getAddrInfo() sometimes returns duplicate addresses,
|
|
|
|
# for example getAddrInfo(`localhost`) returns `127.0.0.1` twice.
|
|
|
|
if ta notin result:
|
2018-06-02 14:25:26 +00:00
|
|
|
result.add(ta)
|
2018-06-10 00:55:19 +00:00
|
|
|
it = it.ai_next
|
|
|
|
freeAddrInfo(aiList)
|
2018-06-02 14:25:26 +00:00
|
|
|
|
2018-06-06 22:15:31 +00:00
|
|
|
proc resolveTAddress*(address: string, port: Port,
|
2018-10-25 10:19:19 +00:00
|
|
|
family = AddressFamily.IPv4): seq[TransportAddress] =
|
2018-06-06 22:15:31 +00:00
|
|
|
## Resolve string representation of ``address``.
|
2018-06-10 00:55:19 +00:00
|
|
|
##
|
2018-06-06 22:15:31 +00:00
|
|
|
## ``address`` could be dot IPv4/IPv6 address or hostname.
|
2018-06-10 00:55:19 +00:00
|
|
|
##
|
2018-06-06 22:15:31 +00:00
|
|
|
## If hostname address is detected, then network address translation via DNS
|
|
|
|
## will be performed.
|
2019-03-14 03:03:32 +00:00
|
|
|
doAssert(family in {AddressFamily.IPv4, AddressFamily.IPv6})
|
2018-10-25 10:19:19 +00:00
|
|
|
|
2018-06-06 22:15:31 +00:00
|
|
|
result = newSeq[TransportAddress]()
|
2018-10-25 10:19:19 +00:00
|
|
|
var domain = if family == AddressFamily.IPv4: Domain.AF_INET else:
|
2018-06-10 00:55:19 +00:00
|
|
|
Domain.AF_INET6
|
|
|
|
var aiList = getAddrInfo(address, port, domain)
|
|
|
|
var it = aiList
|
|
|
|
while it != nil:
|
|
|
|
var ta: TransportAddress
|
2018-10-25 10:19:19 +00:00
|
|
|
fromSAddr(cast[ptr Sockaddr_storage](it.ai_addr),
|
|
|
|
SockLen(it.ai_addrlen), ta)
|
2018-06-10 00:55:19 +00:00
|
|
|
# For some reason getAddrInfo() sometimes returns duplicate addresses,
|
|
|
|
# for example getAddrInfo(`localhost`) returns `127.0.0.1` twice.
|
|
|
|
if ta notin result:
|
|
|
|
result.add(ta)
|
|
|
|
it = it.ai_next
|
|
|
|
freeAddrInfo(aiList)
|
2018-06-06 22:15:31 +00:00
|
|
|
|
2018-10-27 13:14:55 +00:00
|
|
|
proc resolveTAddress*(address: string,
|
|
|
|
family: IpAddressFamily): seq[TransportAddress] {.
|
|
|
|
deprecated.} =
|
|
|
|
if family == IpAddressFamily.IPv4:
|
|
|
|
result = resolveTAddress(address, AddressFamily.IPv4)
|
|
|
|
elif family == IpAddressFamily.IPv6:
|
|
|
|
result = resolveTAddress(address, AddressFamily.IPv6)
|
|
|
|
|
|
|
|
proc resolveTAddress*(address: string, port: Port,
|
|
|
|
family: IpAddressFamily): seq[TransportAddress] {.
|
|
|
|
deprecated.} =
|
|
|
|
if family == IpAddressFamily.IPv4:
|
|
|
|
result = resolveTAddress(address, port, AddressFamily.IPv4)
|
|
|
|
elif family == IpAddressFamily.IPv6:
|
2019-02-06 14:49:11 +00:00
|
|
|
result = resolveTAddress(address, port, AddressFamily.IPv6)
|
2018-10-27 13:14:55 +00:00
|
|
|
|
2020-02-25 21:50:39 +00:00
|
|
|
proc windowsAnyAddressFix*(a: TransportAddress): TransportAddress {.inline.} =
|
|
|
|
## BSD Sockets on *nix systems are able to perform connections to
|
|
|
|
## `0.0.0.0` or `::0` which are equal to `127.0.0.1` or `::1`.
|
|
|
|
when defined(windows):
|
|
|
|
if (a.family == AddressFamily.IPv4 and
|
|
|
|
a.address_v4 == AnyAddress.address_v4):
|
|
|
|
result = initTAddress("127.0.0.1", a.port)
|
|
|
|
elif (a.family == AddressFamily.IPv6 and
|
|
|
|
a.address_v6 == AnyAddress6.address_v6):
|
|
|
|
result = initTAddress("::1", a.port)
|
|
|
|
else:
|
|
|
|
result = a
|
|
|
|
else:
|
|
|
|
result = a
|
|
|
|
|
2018-05-16 08:22:34 +00:00
|
|
|
template checkClosed*(t: untyped) =
|
|
|
|
if (ReadClosed in (t).state) or (WriteClosed in (t).state):
|
2020-05-13 19:45:40 +00:00
|
|
|
raise newException(TransportUseClosedError, "Transport is already closed!")
|
2018-05-16 08:22:34 +00:00
|
|
|
|
2018-06-05 20:21:07 +00:00
|
|
|
template checkClosed*(t: untyped, future: untyped) =
|
|
|
|
if (ReadClosed in (t).state) or (WriteClosed in (t).state):
|
2020-06-24 08:21:52 +00:00
|
|
|
future.fail(newException(TransportUseClosedError,
|
|
|
|
"Transport is already closed!"))
|
2019-10-23 11:13:23 +00:00
|
|
|
return future
|
|
|
|
|
|
|
|
template checkWriteEof*(t: untyped, future: untyped) =
|
|
|
|
if (WriteEof in (t).state):
|
|
|
|
future.fail(newException(TransportError,
|
|
|
|
"Transport connection is already dropped!"))
|
2018-06-05 20:21:07 +00:00
|
|
|
return future
|
|
|
|
|
2018-05-16 08:22:34 +00:00
|
|
|
template getError*(t: untyped): ref Exception =
|
|
|
|
var err = (t).error
|
|
|
|
(t).error = nil
|
|
|
|
err
|
|
|
|
|
2020-06-24 08:21:52 +00:00
|
|
|
template getServerUseClosedError*(): ref TransportUseClosedError =
|
|
|
|
newException(TransportUseClosedError, "Server is already closed!")
|
|
|
|
|
|
|
|
template getTransportTooManyError*(): ref TransportTooManyError =
|
|
|
|
newException(TransportTooManyError, "Too many open transports!")
|
|
|
|
|
2020-11-18 09:30:33 +00:00
|
|
|
template getTransportUseClosedError*(): ref TransportUseClosedError =
|
|
|
|
newException(TransportUseClosedError, "Transport is already closed!")
|
|
|
|
|
2018-10-03 00:44:39 +00:00
|
|
|
template getTransportOsError*(err: OSErrorCode): ref TransportOsError =
|
|
|
|
var msg = "(" & $int(err) & ") " & osErrorMsg(err)
|
|
|
|
var tre = newException(TransportOsError, msg)
|
|
|
|
tre.code = err
|
|
|
|
tre
|
|
|
|
|
|
|
|
template getTransportOsError*(err: cint): ref TransportOsError =
|
|
|
|
getTransportOsError(OSErrorCode(err))
|
2018-06-10 23:08:17 +00:00
|
|
|
|
2018-10-25 10:19:19 +00:00
|
|
|
proc raiseTransportOsError*(err: OSErrorCode) =
|
|
|
|
## Raises transport specific OS error.
|
|
|
|
raise getTransportOsError(err)
|
|
|
|
|
2018-06-15 10:54:26 +00:00
|
|
|
type
|
|
|
|
SeqHeader = object
|
|
|
|
length, reserved: int
|
|
|
|
|
|
|
|
proc isLiteral*(s: string): bool {.inline.} =
|
2021-03-03 18:04:09 +00:00
|
|
|
when defined(gcOrc) or defined(gcArc):
|
|
|
|
false
|
|
|
|
else:
|
|
|
|
(cast[ptr SeqHeader](s).reserved and (1 shl (sizeof(int) * 8 - 2))) != 0
|
2018-06-15 10:54:26 +00:00
|
|
|
|
|
|
|
proc isLiteral*[T](s: seq[T]): bool {.inline.} =
|
2021-03-03 18:04:09 +00:00
|
|
|
when defined(gcOrc) or defined(gcArc):
|
|
|
|
false
|
|
|
|
else:
|
|
|
|
(cast[ptr SeqHeader](s).reserved and (1 shl (sizeof(int) * 8 - 2))) != 0
|
2018-06-15 10:54:26 +00:00
|
|
|
|
2018-05-16 08:22:34 +00:00
|
|
|
when defined(windows):
|
|
|
|
import winlean
|
|
|
|
|
2018-10-03 00:44:39 +00:00
|
|
|
const
|
|
|
|
ERROR_OPERATION_ABORTED* = 995
|
2018-10-25 10:19:19 +00:00
|
|
|
ERROR_PIPE_CONNECTED* = 535
|
|
|
|
ERROR_PIPE_BUSY* = 231
|
2018-10-03 00:44:39 +00:00
|
|
|
ERROR_SUCCESS* = 0
|
|
|
|
ERROR_CONNECTION_REFUSED* = 1225
|
2018-10-25 10:19:19 +00:00
|
|
|
PIPE_TYPE_BYTE* = 0
|
|
|
|
PIPE_READMODE_BYTE* = 0
|
|
|
|
PIPE_TYPE_MESSAGE* = 0x4
|
|
|
|
PIPE_READMODE_MESSAGE* = 0x2
|
|
|
|
PIPE_WAIT* = 0
|
|
|
|
PIPE_UNLIMITED_INSTANCES* = 255
|
|
|
|
ERROR_BROKEN_PIPE* = 109
|
|
|
|
ERROR_PIPE_NOT_CONNECTED* = 233
|
|
|
|
ERROR_NO_DATA* = 232
|
2019-03-30 22:31:10 +00:00
|
|
|
ERROR_CONNECTION_ABORTED* = 1236
|
2020-06-24 08:21:52 +00:00
|
|
|
ERROR_TOO_MANY_OPEN_FILES* = 4
|
2018-10-03 00:44:39 +00:00
|
|
|
|
2018-05-16 08:22:34 +00:00
|
|
|
proc cancelIo*(hFile: HANDLE): WINBOOL
|
|
|
|
{.stdcall, dynlib: "kernel32", importc: "CancelIo".}
|
2018-10-25 10:19:19 +00:00
|
|
|
proc connectNamedPipe*(hPipe: HANDLE, lpOverlapped: ptr OVERLAPPED): WINBOOL
|
|
|
|
{.stdcall, dynlib: "kernel32", importc: "ConnectNamedPipe".}
|
|
|
|
proc disconnectNamedPipe*(hPipe: HANDLE): WINBOOL
|
|
|
|
{.stdcall, dynlib: "kernel32", importc: "DisconnectNamedPipe".}
|
|
|
|
proc setNamedPipeHandleState*(hPipe: HANDLE, lpMode, lpMaxCollectionCount,
|
|
|
|
lpCollectDataTimeout: ptr DWORD): WINBOOL
|
|
|
|
{.stdcall, dynlib: "kernel32", importc: "SetNamedPipeHandleState".}
|
|
|
|
proc resetEvent*(hEvent: HANDLE): WINBOOL
|
|
|
|
{.stdcall, dynlib: "kernel32", importc: "ResetEvent".}
|