130 lines
3.8 KiB
Nim
130 lines
3.8 KiB
Nim
## Nim-LibP2P
|
|
## Copyright (c) 2019 Status Research & Development GmbH
|
|
## Licensed under either of
|
|
## * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
|
|
## * MIT license ([LICENSE-MIT](LICENSE-MIT))
|
|
## at your option.
|
|
## This file may not be copied, modified, or distributed except according to
|
|
## those terms.
|
|
|
|
import std/[options, strformat]
|
|
import chronos, chronicles, bearssl
|
|
import ../protocol,
|
|
../../stream/streamseq,
|
|
../../stream/connection,
|
|
../../multiaddress,
|
|
../../peerinfo
|
|
|
|
logScope:
|
|
topics = "secure"
|
|
|
|
type
|
|
Secure* = ref object of LPProtocol # base type for secure managers
|
|
|
|
SecureConn* = ref object of Connection
|
|
stream*: Connection
|
|
buf: StreamSeq
|
|
|
|
func shortLog*(conn: SecureConn): auto =
|
|
if conn.isNil: "SecureConn(nil)"
|
|
elif conn.peerInfo.isNil: $conn.oid
|
|
else: &"{shortLog(conn.peerInfo.peerId)}:{conn.oid}"
|
|
chronicles.formatIt(SecureConn): shortLog(it)
|
|
|
|
proc init*(T: type SecureConn,
|
|
conn: Connection,
|
|
peerInfo: PeerInfo,
|
|
observedAddr: Multiaddress,
|
|
timeout: Duration = DefaultConnectionTimeout): T =
|
|
result = T(stream: conn,
|
|
peerInfo: peerInfo,
|
|
observedAddr: observedAddr,
|
|
closeEvent: conn.closeEvent,
|
|
timeout: timeout)
|
|
result.initStream()
|
|
|
|
method initStream*(s: SecureConn) =
|
|
if s.objName.len == 0:
|
|
s.objName = "SecureConn"
|
|
|
|
procCall Connection(s).initStream()
|
|
|
|
method close*(s: SecureConn) {.async.} =
|
|
if not(isNil(s.stream)):
|
|
await s.stream.close()
|
|
|
|
await procCall Connection(s).close()
|
|
|
|
method readMessage*(c: SecureConn): Future[seq[byte]] {.async, base.} =
|
|
doAssert(false, "Not implemented!")
|
|
|
|
method handshake(s: Secure,
|
|
conn: Connection,
|
|
initiator: bool): Future[SecureConn] {.async, base.} =
|
|
doAssert(false, "Not implemented!")
|
|
|
|
proc handleConn*(s: Secure,
|
|
conn: Connection,
|
|
initiator: bool): Future[Connection] {.async, gcsafe.} =
|
|
var sconn = await s.handshake(conn, initiator)
|
|
|
|
proc cleanup() {.async.} =
|
|
try:
|
|
await conn.join()
|
|
await sconn.close()
|
|
except CancelledError:
|
|
# This is top-level procedure which will work as separate task, so it
|
|
# do not need to propogate CancelledError.
|
|
discard
|
|
except CatchableError as exc:
|
|
trace "error cleaning up secure connection", err = exc.msg, sconn
|
|
|
|
if not isNil(sconn):
|
|
# All the errors are handled inside `cleanup()` procedure.
|
|
asyncSpawn cleanup()
|
|
|
|
return sconn
|
|
|
|
method init*(s: Secure) {.gcsafe.} =
|
|
procCall LPProtocol(s).init()
|
|
|
|
proc handle(conn: Connection, proto: string) {.async, gcsafe.} =
|
|
trace "handling connection upgrade", proto, conn
|
|
try:
|
|
# We don't need the result but we
|
|
# definitely need to await the handshake
|
|
discard await s.handleConn(conn, false)
|
|
trace "connection secured", conn
|
|
except CancelledError as exc:
|
|
warn "securing connection canceled", conn
|
|
await conn.close()
|
|
raise exc
|
|
except CatchableError as exc:
|
|
warn "securing connection failed", err = exc.msg, conn
|
|
await conn.close()
|
|
|
|
s.handler = handle
|
|
|
|
method secure*(s: Secure,
|
|
conn: Connection,
|
|
initiator: bool):
|
|
Future[Connection] {.async, base, gcsafe.} =
|
|
result = await s.handleConn(conn, initiator)
|
|
|
|
method readOnce*(s: SecureConn,
|
|
pbytes: pointer,
|
|
nbytes: int):
|
|
Future[int] {.async, gcsafe.} =
|
|
if nbytes == 0:
|
|
return 0
|
|
|
|
if s.buf.data().len() == 0:
|
|
let buf = await s.readMessage()
|
|
s.activity = true
|
|
if buf.len == 0:
|
|
raise newLPStreamIncompleteError()
|
|
s.buf.add(buf)
|
|
|
|
var p = cast[ptr UncheckedArray[byte]](pbytes)
|
|
return s.buf.consumeTo(toOpenArray(p, 0, nbytes - 1))
|