jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix sendTo and recvFrom in asyncnet (#14154)

Browse source 
* added high level sendTo and recvFrom to std/asyncnet; tests were also added.

* add .since annotation, a changelog entry and fixed to standard library style guide.

* Improved asserts msgs and added notes for use with UDP sockets

* pointers removed in parameters and fixes

* added .since annotation

* minor fixes
This commit is contained in:
rockcavera 2020-04-30 17:50:37 -03:00 • committed by GitHub
commit 33e9ac7cd3
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 50 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

112
lib/pure/asyncnet.nim
View file

@ -780,8 +780,8 @@ proc isClosed*(socket: AsyncSocket): bool =
## Determines whether the socket has been closed. ## Determines whether the socket has been closed.
return socket.closed return socket.closed
proc sendTo*(socket: AsyncSocket, data: pointer, dataSize: int, address: string, proc sendTo*(socket: AsyncSocket, address: string, port: Port, data: string,
port: Port, flags = {SocketFlag.SafeDisconn}): owned(Future[void]) flags = {SocketFlag.SafeDisconn}): owned(Future[void])
{.async, since: (1, 3).} = {.async, since: (1, 3).} =
## This proc sends ``data`` to the specified ``address``, which may be an IP ## This proc sends ``data`` to the specified ``address``, which may be an IP
## address or a hostname. If a hostname is specified this function will try ## address or a hostname. If a hostname is specified this function will try
@ -792,13 +792,11 @@ proc sendTo*(socket: AsyncSocket, data: pointer, dataSize: int, address: string,
## ##
## This proc is normally used with connectionless sockets (UDP sockets). ## This proc is normally used with connectionless sockets (UDP sockets).
assert(socket.protocol != IPPROTO_TCP, assert(socket.protocol != IPPROTO_TCP,
"Cannot `sendTo` on a TCP socket. Use `send` instead.") "Cannot `sendTo` on a TCP socket. Use `send` instead")
assert(not socket.closed, "Cannot `sendTo` on a closed socket.") assert(not socket.closed, "Cannot `sendTo` on a closed socket")
let let aiList = getAddrInfo(address, port, socket.domain, socket.sockType,
aiList = getAddrInfo(address, port, socket.domain, socket.sockType, socket.protocol)
socket.protocol)
retFuture = newFuture[void]("sendTo")
var var
it = aiList it = aiList
@ -806,7 +804,7 @@ proc sendTo*(socket: AsyncSocket, data: pointer, dataSize: int, address: string,
lastException: ref Exception lastException: ref Exception
while it != nil: while it != nil:
let fut = sendTo(socket.fd.AsyncFD, data, dataSize, it.ai_addr, let fut = sendTo(socket.fd.AsyncFD, cstring(data), len(data), it.ai_addr,
it.ai_addrlen.SockLen, flags) it.ai_addrlen.SockLen, flags)
yield fut yield fut
@ -824,88 +822,54 @@ proc sendTo*(socket: AsyncSocket, data: pointer, dataSize: int, address: string,
if not success: if not success:
if lastException != nil: if lastException != nil:
retFuture.fail(lastException) raise lastException
else: else:
retFuture.fail(newException( raise newException(IOError, "Couldn't resolve address: " & address)
IOError, "Couldn't resolve address: " & address))
else: proc recvFrom*(socket: AsyncSocket, size: int,
retFuture.complete() flags = {SocketFlag.SafeDisconn}):
owned(Future[tuple[data: string, address: string, port: Port]])
proc sendTo*(socket: AsyncSocket, data, address: string, port: Port):
owned(Future[void]) {.async, since: (1, 3).} =
## This proc sends ``data`` to the specified ``address``, which may be an IP
## address or a hostname. If a hostname is specified this function will try
## each IP of that hostname. The returned future will complete once all data
## has been sent.
##
## If an error occurs an OSError exception will be raised.
##
## This proc is normally used with connectionless sockets (UDP sockets).
await sendTo(socket, cstring(data), len(data), address, port)
proc recvFrom*(socket: AsyncSocket, data: pointer, size: int,
address: FutureVar[string], port: FutureVar[Port],
flags = {SocketFlag.SafeDisconn}): owned(Future[int])
{.async, since: (1, 3).} = {.async, since: (1, 3).} =
## Receives a datagram data from ``socket`` into ``data``, which must be at ## Receives a datagram data from ``socket``, which must be at least of size
## least of size ``size``. The address and port of datagram's sender will be ## ``size``. Returned future will complete once one datagram has been received
## stored into ``address`` and ``port``, respectively. Returned future will ## and will return tuple with: data of packet received; and address and port
## complete once one datagram has been received, and will return size of ## of datagram's sender.
## packet received.
## ##
## If an error occurs an OSError exception will be raised. ## If an error occurs an OSError exception will be raised.
## ##
## This proc is normally used with connectionless sockets (UDP sockets). ## This proc is normally used with connectionless sockets (UDP sockets).
template awaitRecvFromInto() = template adaptRecvFromToDomain(domain: Domain) =
var lAddr = sizeof(sAddr).SockLen var lAddr = sizeof(sAddr).SockLen
result = await recvFromInto(AsyncFD(getFd(socket)), data, size, let fut = await recvFromInto(AsyncFD(getFd(socket)), cstring(data), size,
cast[ptr SockAddr](addr sAddr), addr lAddr) cast[ptr SockAddr](addr sAddr), addr lAddr,
flags)
address.mget.add(getAddrString(cast[ptr SockAddr](addr sAddr))) data.setLen(fut)
address.complete() result.data = data
result.address = getAddrString(cast[ptr SockAddr](addr sAddr))
when domain == AF_INET6:
result.port = ntohs(sAddr.sin6_port).Port
else:
result.port = ntohs(sAddr.sin_port).Port
assert(socket.protocol != IPPROTO_TCP, assert(socket.protocol != IPPROTO_TCP,
"Cannot `recvFrom` on a TCP socket. Use `recv` or `recvInto` instead.") "Cannot `recvFrom` on a TCP socket. Use `recv` or `recvInto` instead")
assert(not socket.closed, "Cannot `recvFrom` on a closed socket.") assert(not socket.closed, "Cannot `recvFrom` on a closed socket")
var readSize: int var data = newString(size)
if socket.domain == AF_INET6: case socket.domain
of AF_INET6:
var sAddr: Sockaddr_in6 var sAddr: Sockaddr_in6
adaptRecvFromToDomain(AF_INET6)
awaitRecvFromInto() of AF_INET:
port.complete(ntohs(sAddr.sin6_port).Port)
else:
var sAddr: Sockaddr_in var sAddr: Sockaddr_in
adaptRecvFromToDomain(AF_INET)
awaitRecvFromInto() else:
raise newException(ValueError, "Unknown socket address family")
port.complete(ntohs(sAddr.sin_port).Port)
proc recvFrom*(socket: AsyncSocket, data: pointer, size: int):
owned(Future[tuple[size: int, address: string, port: Port]])
{.async, since: (1, 3).} =
## Receives a datagram data from ``socket`` into ``data``, which must be at
## least of size ``size``. Returned future will complete once one datagram has
## been received and will return tuple with: size of packet received; and
## address and port of datagram's sender.
##
## If an error occurs an OSError exception will be raised.
##
## This proc is normally used with connectionless sockets (UDP sockets).
var
fromIp = newFutureVar[string]()
fromPort = newFutureVar[Port]()
result.size = await recvFrom(socket, data, size, fromIp, fromPort)
result.address = fromIp.mget()
result.port = fromPort.mget()
when not defined(testing) and isMainModule: when not defined(testing) and isMainModule:
type type

25
tests/async/tasyncnetudp.nim
View file

@ -21,9 +21,7 @@ proc saveReceivedPort(port: Port) =
recvports = recvports + int(port) recvports = recvports + int(port)
proc launchSwarm(serverIp: string, serverPort: Port) {.async.} = proc launchSwarm(serverIp: string, serverPort: Port) {.async.} =
var var i = 0
buffer = newString(16384)
i = 0
while i < swarmSize: while i < swarmSize:
var sock = newAsyncSocket(nativesockets.AF_INET, nativesockets.SOCK_DGRAM, var sock = newAsyncSocket(nativesockets.AF_INET, nativesockets.SOCK_DGRAM,
@ -36,16 +34,13 @@ proc launchSwarm(serverIp: string, serverPort: Port) {.async.} =
var k = 0 var k = 0
while k < messagesToSend: while k < messagesToSend:
zeroMem(addr(buffer[0]), 16384)
let message = "Message " & $(i * messagesToSend + k) let message = "Message " & $(i * messagesToSend + k)
await sendTo(sock, message, serverIp, serverPort) await asyncnet.sendTo(sock, serverIp, serverPort, message)
let (size, fromIp, fromPort) = await recvFrom(sock, addr buffer[0], let (data, fromIp, fromPort) = await recvFrom(sock, 16384)
16384)
if buffer[0 .. (size - 1)] == message: if data == message:
saveSendingPort(localPort) saveSendingPort(localPort)
inc(recvCount) inc(recvCount)
@ -59,17 +54,13 @@ proc launchSwarm(serverIp: string, serverPort: Port) {.async.} =
proc readMessages(server: AsyncSocket) {.async.} = proc readMessages(server: AsyncSocket) {.async.} =
let maxResponses = (swarmSize * messagesToSend) let maxResponses = (swarmSize * messagesToSend)
var var i = 0
buffer = newString(16384)
i = 0
while i < maxResponses: while i < maxResponses:
zeroMem(addr(buffer[0]), 16384) let (data, fromIp, fromPort) = await recvFrom(server, 16384)
let (size, fromIp, fromPort) = await recvFrom(server, addr buffer[0], 16384) if data.startswith("Message ") and fromIp == "127.0.0.1":
await sendTo(server, fromIp, fromPort, data)
if buffer.startswith("Message ") and fromIp == "127.0.0.1":
await sendTo(server, buffer[0 .. (size - 1)], fromIp, fromPort)
inc(msgCount) inc(msgCount)