mirror of
https://github.com/vacp2p/nim-quic.git
synced 2026-01-09 22:08:09 -05:00
remove unused code
This commit is contained in:
Vlado Pajić
@@ -1,87 +0,0 @@
|
||||
import ../basics
|
||||
import ./packets/packet
|
||||
import ./packets/length
|
||||
import ./packets/read
|
||||
import ./packets/write
|
||||
|
||||
{.push raises: [QuicError].}
|
||||
|
||||
export packet
|
||||
export length
|
||||
|
||||
proc read(reader: var PacketReader, datagram: openArray[byte]): Packet =
|
||||
reader.readForm(datagram)
|
||||
reader.readFixedBit(datagram)
|
||||
case reader.packet.form
|
||||
of formShort:
|
||||
reader.readSpinBit(datagram)
|
||||
reader.readKeyPhase(datagram)
|
||||
reader.readShortDestination(datagram)
|
||||
reader.readPacketNumberAndPayload(datagram)
|
||||
of formLong:
|
||||
reader.readKind(datagram)
|
||||
reader.readVersion(datagram)
|
||||
reader.readDestination(datagram)
|
||||
reader.readSource(datagram)
|
||||
case reader.packet.kind
|
||||
of packetVersionNegotiation:
|
||||
reader.readSupportedVersions(datagram)
|
||||
of packetRetry:
|
||||
reader.readRetryToken(datagram)
|
||||
reader.readIntegrity(datagram)
|
||||
of packetHandshake, packet0RTT:
|
||||
reader.readPacketNumberAndPayload(datagram)
|
||||
of packetInitial:
|
||||
reader.readInitialToken(datagram)
|
||||
reader.readPacketNumberAndPayload(datagram)
|
||||
reader.packet
|
||||
|
||||
proc readPacket*(datagram: openArray[byte]): Packet =
|
||||
var reader = PacketReader()
|
||||
reader.read(datagram)
|
||||
|
||||
proc readPackets*(datagram: openArray[byte]): seq[Packet] =
|
||||
var reader = PacketReader()
|
||||
while reader.next < datagram.len:
|
||||
reader.nextPacket()
|
||||
result.add(reader.read(datagram))
|
||||
|
||||
proc write(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
writer.writeForm(datagram)
|
||||
writer.writeFixedBit(datagram)
|
||||
case writer.packet.form
|
||||
of formShort:
|
||||
writer.writeSpinBit(datagram)
|
||||
writer.writeReservedBits(datagram)
|
||||
writer.writeKeyPhase(datagram)
|
||||
writer.writeShortDestination(datagram)
|
||||
writer.writePacketNumberAndPayload(datagram)
|
||||
of formLong:
|
||||
writer.writeKind(datagram)
|
||||
writer.writeVersion(datagram)
|
||||
writer.writeDestination(datagram)
|
||||
writer.writeSource(datagram)
|
||||
case writer.packet.kind
|
||||
of packetVersionNegotiation:
|
||||
writer.writeSupportedVersions(datagram)
|
||||
of packetRetry:
|
||||
writer.writeToken(datagram)
|
||||
writer.writeIntegrity(datagram)
|
||||
of packetHandshake, packet0RTT:
|
||||
writer.writePacketNumberAndPayload(datagram)
|
||||
of packetInitial:
|
||||
writer.writeTokenLength(datagram)
|
||||
writer.writeToken(datagram)
|
||||
writer.writePacketNumberAndPayload(datagram)
|
||||
|
||||
proc write*(datagram: var openArray[byte], packet: Packet): int {.discardable.} =
|
||||
var writer = PacketWriter(packet: packet)
|
||||
writer.write(datagram)
|
||||
writer.bytesWritten
|
||||
|
||||
proc write*(datagram: var openArray[byte], packets: seq[Packet]): int {.discardable.} =
|
||||
var writer = PacketWriter()
|
||||
for packet in packets:
|
||||
writer.nextPacket(packet)
|
||||
writer.write(datagram)
|
||||
writer.bytesWritten
|
||||
@@ -1,36 +0,0 @@
|
||||
import ./varints
|
||||
import ./packet
|
||||
import ./packetnumber
|
||||
|
||||
{.push raises: [].}
|
||||
|
||||
proc len*(packet: Packet): int =
|
||||
case packet.form
|
||||
of formShort:
|
||||
return
|
||||
1 + packet.destination.len + packet.short.packetnumber.toMinimalBytes.len +
|
||||
packet.short.payload.len
|
||||
of formLong:
|
||||
case packet.kind
|
||||
of packetVersionNegotiation:
|
||||
return
|
||||
7 + packet.destination.len + packet.source.len +
|
||||
packet.negotiation.supportedVersions.len * 4
|
||||
of packetRetry:
|
||||
return 23 + packet.destination.len + packet.source.len + packet.retry.token.len
|
||||
of packetHandshake:
|
||||
return
|
||||
7 + packet.destination.len + packet.source.len +
|
||||
packet.handshake.payload.len.toVarInt.len +
|
||||
packet.handshake.packetnumber.toMinimalBytes.len + packet.handshake.payload.len
|
||||
of packet0RTT:
|
||||
return
|
||||
7 + packet.destination.len + packet.source.len +
|
||||
packet.rtt.payload.len.toVarInt.len + packet.rtt.packetnumber.toMinimalBytes.len +
|
||||
packet.rtt.payload.len
|
||||
of packetInitial:
|
||||
return
|
||||
7 + packet.destination.len + packet.source.len +
|
||||
packet.initial.token.len.toVarInt.len + packet.initial.token.len +
|
||||
packet.initial.payload.len.toVarInt.len +
|
||||
packet.initial.packetnumber.toMinimalBytes.len + packet.initial.payload.len
|
||||
@@ -1,116 +0,0 @@
|
||||
import ../../basics
|
||||
import ../connectionid
|
||||
import ../version
|
||||
import ./packetnumber
|
||||
|
||||
export connectionid
|
||||
export PacketNumber
|
||||
|
||||
type
|
||||
PacketForm* = enum
|
||||
formShort
|
||||
formLong
|
||||
|
||||
PacketKind* = enum
|
||||
packetInitial
|
||||
packet0RTT
|
||||
packetHandshake
|
||||
packetRetry
|
||||
packetVersionNegotiation
|
||||
|
||||
PacketShort* = object
|
||||
spinBit*: bool
|
||||
keyPhase*: bool
|
||||
packetnumber*: PacketNumber
|
||||
payload*: seq[byte]
|
||||
|
||||
PacketInitial* = object
|
||||
version*: uint32
|
||||
token*: seq[byte]
|
||||
packetnumber*: PacketNumber
|
||||
payload*: seq[byte]
|
||||
|
||||
Packet0RTT* = object
|
||||
version*: uint32
|
||||
packetnumber*: PacketNumber
|
||||
payload*: seq[byte]
|
||||
|
||||
PacketHandshake* = object
|
||||
version*: uint32
|
||||
packetnumber*: PacketNumber
|
||||
payload*: seq[byte]
|
||||
|
||||
PacketRetry* = object
|
||||
version*: uint32
|
||||
token*: seq[byte]
|
||||
integrity*: array[16, byte]
|
||||
|
||||
PacketVersionNegotiation* = object
|
||||
supportedVersions*: seq[uint32]
|
||||
|
||||
Packet* = object
|
||||
case form*: PacketForm
|
||||
of formShort:
|
||||
short*: PacketShort
|
||||
of formLong:
|
||||
case kind*: PacketKind
|
||||
of packetInitial:
|
||||
initial*: PacketInitial
|
||||
of packet0RTT:
|
||||
rtt*: Packet0RTT
|
||||
of packetHandshake:
|
||||
handshake*: PacketHandshake
|
||||
of packetRetry:
|
||||
retry*: PacketRetry
|
||||
of packetVersionNegotiation:
|
||||
negotiation*: PacketVersionNegotiation
|
||||
source*: ConnectionId
|
||||
destination*: ConnectionId
|
||||
|
||||
proc shortPacket*(): Packet =
|
||||
Packet(form: formShort)
|
||||
|
||||
proc initialPacket*(version = CurrentQuicVersion): Packet =
|
||||
result = Packet(form: formLong, kind: packetInitial)
|
||||
result.initial.version = version
|
||||
|
||||
proc zeroRttPacket*(version = CurrentQuicVersion): Packet =
|
||||
result = Packet(form: formLong, kind: packet0RTT)
|
||||
result.rtt.version = version
|
||||
|
||||
proc handshakePacket*(version = CurrentQuicVersion): Packet =
|
||||
result = Packet(form: formLong, kind: packetHandshake)
|
||||
result.handshake.version = version
|
||||
|
||||
proc retryPacket*(version = CurrentQuicVersion): Packet =
|
||||
result = Packet(form: formLong, kind: packetRetry)
|
||||
result.retry.version = version
|
||||
|
||||
proc versionNegotiationPacket*(versions = @[CurrentQuicVersion]): Packet =
|
||||
result = Packet(form: formLong, kind: packetVersionNegotiation)
|
||||
result.negotiation.supportedVersions = versions
|
||||
|
||||
proc `==`*(a, b: Packet): bool =
|
||||
if a.form != b.form:
|
||||
return false
|
||||
if a.destination != b.destination:
|
||||
return false
|
||||
case a.form
|
||||
of formShort:
|
||||
a.short == b.short
|
||||
of formLong:
|
||||
if a.kind != b.kind:
|
||||
return false
|
||||
if a.source != b.source:
|
||||
return false
|
||||
case a.kind
|
||||
of packetInitial:
|
||||
a.initial == b.initial
|
||||
of packet0RTT:
|
||||
a.retry == b.retry
|
||||
of packetHandshake:
|
||||
a.handshake == b.handshake
|
||||
of packetRetry:
|
||||
a.retry == b.retry
|
||||
of packetVersionNegotiation:
|
||||
a.negotiation == b.negotiation
|
||||
@@ -1,11 +0,0 @@
|
||||
import std/math
|
||||
import pkg/stew/endians2
|
||||
|
||||
type PacketNumber* = range[0'i64 .. 2'i64 ^ 62 - 1]
|
||||
|
||||
proc toMinimalBytes*(packetnumber: PacketNumber): seq[byte] =
|
||||
let bytes = packetnumber.uint64.toBytesBE
|
||||
var length = bytes.len
|
||||
while length > 1 and bytes[bytes.len - length] == 0:
|
||||
length = length - 1
|
||||
bytes[bytes.len - length ..< bytes.len]
|
||||
@@ -1,156 +0,0 @@
|
||||
import pkg/stew/endians2
|
||||
import ../../basics
|
||||
import ../../helpers/bits
|
||||
import ./varints
|
||||
import ./packet
|
||||
import ./reader
|
||||
|
||||
{.push raises: [QuicError].}
|
||||
|
||||
export reader
|
||||
|
||||
proc readForm*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
reader.packet = Packet(form: PacketForm(datagram[reader.next].bits[0]))
|
||||
|
||||
proc readFixedBit*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
if datagram[reader.next].bits[1] != 1:
|
||||
raise newException(QuicError, "Unexpected fixed bit value")
|
||||
|
||||
proc peekVersion(reader: var PacketReader, datagram: openArray[byte]): uint32 =
|
||||
fromBytesBE(uint32, reader.peek(datagram, 4))
|
||||
|
||||
proc `version=`(packet: var Packet, version: uint32) =
|
||||
case packet.kind
|
||||
of packetInitial:
|
||||
packet.initial.version = version
|
||||
of packet0RTT:
|
||||
packet.rtt.version = version
|
||||
of packetHandshake:
|
||||
packet.handshake.version = version
|
||||
of packetRetry:
|
||||
packet.retry.version = version
|
||||
of packetVersionNegotiation:
|
||||
discard
|
||||
|
||||
proc readVersion*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
reader.packet.version = fromBytesBE(uint32, reader.read(datagram, 4))
|
||||
|
||||
proc readSupportedVersions*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
var versions: seq[uint32]
|
||||
while reader.next < datagram.len:
|
||||
versions.add(fromBytesBE(uint32, reader.read(datagram, 4)))
|
||||
reader.packet.negotiation.supportedVersions = versions
|
||||
|
||||
proc readKind*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
var kind: uint8
|
||||
kind.bits[6] = datagram[reader.next].bits[2]
|
||||
kind.bits[7] = datagram[reader.next].bits[3]
|
||||
reader.move(1)
|
||||
if reader.peekVersion(datagram) == 0:
|
||||
reader.packet = Packet(form: formLong, kind: packetVersionNegotiation)
|
||||
else:
|
||||
reader.packet = Packet(form: formLong, kind: PacketKind(kind))
|
||||
|
||||
proc readConnectionId(
|
||||
reader: var PacketReader, datagram: openArray[byte]
|
||||
): ConnectionId =
|
||||
let length = reader.read(datagram).int
|
||||
ConnectionId(reader.read(datagram, length))
|
||||
|
||||
proc readDestination*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
reader.packet.destination = reader.readConnectionId(datagram)
|
||||
|
||||
proc readSource*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
reader.packet.source = reader.readConnectionId(datagram)
|
||||
|
||||
proc readRetryToken*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
let length = datagram.len - 16 - reader.next
|
||||
reader.packet.retry.token = reader.read(datagram, length)
|
||||
|
||||
proc readIntegrity*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
try:
|
||||
reader.packet.retry.integrity[0 ..< 16] = reader.read(datagram, 16)
|
||||
except RangeError:
|
||||
doAssert false, "programmer error: assignment ranges do not match"
|
||||
|
||||
proc readVarInt(reader: var PacketReader, datagram: openArray[byte]): VarIntCompatible =
|
||||
result = fromVarInt(datagram.toOpenArray(reader.next, datagram.len - 1))
|
||||
reader.move(varintlen(datagram.toOpenArray(reader.next, datagram.len - 1)))
|
||||
|
||||
proc `packetnumber=`(packet: var Packet, number: PacketNumber) =
|
||||
case packet.form
|
||||
of formShort:
|
||||
packet.short.packetnumber = number
|
||||
of formLong:
|
||||
case packet.kind
|
||||
of packetHandshake:
|
||||
packet.handshake.packetnumber = number
|
||||
of packet0RTT:
|
||||
packet.rtt.packetnumber = number
|
||||
of packetInitial:
|
||||
packet.initial.packetnumber = number
|
||||
else:
|
||||
discard
|
||||
|
||||
proc readPacketNumberLength(
|
||||
reader: var PacketReader, datagram: openArray[byte]
|
||||
): range[1 .. 4] =
|
||||
1 + int(datagram[reader.first] and 0b11)
|
||||
|
||||
proc readPacketNumber(
|
||||
reader: var PacketReader, datagram: openArray[byte], length: range[1 .. 4]
|
||||
) =
|
||||
let bytes = reader.read(datagram, length)
|
||||
var padded: array[4, byte]
|
||||
try:
|
||||
padded[padded.len - bytes.len ..< padded.len] = bytes
|
||||
except RangeError:
|
||||
doAssert false, "programmer error: assignment ranges do not match"
|
||||
reader.packet.packetnumber = fromBytesBE(uint32, padded).int64
|
||||
|
||||
proc `payload=`(packet: var Packet, payload: seq[byte]) =
|
||||
case packet.form
|
||||
of formShort:
|
||||
packet.short.payload = payload
|
||||
of formLong:
|
||||
case packet.kind
|
||||
of packetHandshake:
|
||||
packet.handshake.payload = payload
|
||||
of packet0RTT:
|
||||
packet.rtt.payload = payload
|
||||
of packetInitial:
|
||||
packet.initial.payload = payload
|
||||
else:
|
||||
discard
|
||||
|
||||
proc readPacketLength(reader: var PacketReader, datagram: openArray[byte]): int =
|
||||
case reader.packet.form
|
||||
of formLong:
|
||||
reader.readVarInt(datagram)
|
||||
of formShort:
|
||||
datagram.len - reader.next
|
||||
|
||||
proc readPayload(reader: var PacketReader, datagram: openArray[byte], length: int) =
|
||||
reader.packet.payload = reader.read(datagram, length)
|
||||
|
||||
proc readPacketNumberAndPayload*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
let length = reader.readPacketLength(datagram)
|
||||
let packetnumberLength = reader.readPacketNumberLength(datagram)
|
||||
let payloadLength = length - packetnumberLength
|
||||
reader.readPacketNumber(datagram, packetnumberLength)
|
||||
reader.readPayload(datagram, payloadLength.int)
|
||||
|
||||
proc readInitialToken*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
let length = reader.readVarInt(datagram)
|
||||
reader.packet.initial.token = reader.read(datagram, length.int)
|
||||
|
||||
proc readSpinBit*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
reader.packet.short.spinBit = bool(datagram[reader.next].bits[2])
|
||||
|
||||
proc readKeyPhase*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
reader.packet.short.keyPhase = bool(datagram[reader.next].bits[5])
|
||||
reader.move(1)
|
||||
|
||||
proc readShortDestination*(reader: var PacketReader, datagram: openArray[byte]) =
|
||||
const length = DefaultConnectionIdLength
|
||||
reader.packet.destination = ConnectionId(reader.read(datagram, length))
|
||||
@@ -1,27 +0,0 @@
|
||||
import ./packet
|
||||
|
||||
type PacketReader* = object
|
||||
packet*: Packet
|
||||
first*, next*: int
|
||||
|
||||
proc peek*(
|
||||
reader: var PacketReader, datagram: openArray[byte], amount: int
|
||||
): seq[byte] =
|
||||
datagram[reader.next ..< reader.next + amount]
|
||||
|
||||
proc move*(reader: var PacketReader, amount: int) =
|
||||
reader.next = reader.next + amount
|
||||
|
||||
proc read*(
|
||||
reader: var PacketReader, datagram: openArray[byte], amount: int
|
||||
): seq[byte] =
|
||||
result = reader.peek(datagram, amount)
|
||||
reader.move(amount)
|
||||
|
||||
proc read*(reader: var PacketReader, datagram: openArray[byte]): byte =
|
||||
result = datagram[reader.next]
|
||||
reader.move(1)
|
||||
|
||||
proc nextPacket*(reader: var PacketReader) =
|
||||
reader.packet = Packet()
|
||||
reader.first = reader.next
|
||||
@@ -1,37 +0,0 @@
|
||||
import std/math
|
||||
import pkg/stew/endians2
|
||||
|
||||
type VarIntCompatible* = range[0'i64 .. 2'i64 ^ 62 - 1]
|
||||
|
||||
proc toVarInt*(value: VarIntCompatible): seq[byte] =
|
||||
case value
|
||||
of 0 .. 2 ^ 6 - 1:
|
||||
@[value.uint8]
|
||||
of 2 ^ 6 .. 2 ^ 14 - 1:
|
||||
const length = 0b01'u16 shl 14
|
||||
@(toBytesBE(length or value.uint16))
|
||||
of 2 ^ 14 .. 2 ^ 30 - 1:
|
||||
const length = 0b10'u32 shl 30
|
||||
@(toBytesBE(length or value.uint32))
|
||||
else:
|
||||
const length = 0b11'u64 shl 62
|
||||
@(toBytesBE(length or value.uint64))
|
||||
|
||||
proc varintlen*(varint: openArray[byte]): int =
|
||||
2 ^ (varint[0] shr 6)
|
||||
|
||||
proc fromVarInt*(varint: openArray[byte]): VarIntCompatible =
|
||||
let r =
|
||||
case varintlen(varint)
|
||||
of 1:
|
||||
varint[0].uint64
|
||||
of 2:
|
||||
const mask = not (0b11'u16 shl 14)
|
||||
fromBytesBE(uint16, varint) and mask
|
||||
of 4:
|
||||
const mask = not (0b11'u32 shl 30)
|
||||
fromBytesBE(uint32, varint) and mask
|
||||
else:
|
||||
const mask = not (0b11'u64 shl 62)
|
||||
fromBytesBE(uint64, varint) and mask
|
||||
r.int64
|
||||
@@ -1,134 +0,0 @@
|
||||
import pkg/stew/endians2
|
||||
import ../../helpers/bits
|
||||
import ./varints
|
||||
import ./packet
|
||||
import ./packetnumber
|
||||
import ./writer
|
||||
export writer
|
||||
|
||||
proc writeForm*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
datagram[writer.next].bits[0] = Bit(writer.packet.form)
|
||||
|
||||
proc writeFixedBit*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
datagram[writer.next].bits[1] = 1
|
||||
|
||||
proc writeKind*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
let kind = writer.packet.kind
|
||||
case kind
|
||||
of packetVersionNegotiation:
|
||||
discard
|
||||
else:
|
||||
datagram[writer.next].bits[2] = kind.uint8.bits[6]
|
||||
datagram[writer.next].bits[3] = kind.uint8.bits[7]
|
||||
writer.move(1)
|
||||
|
||||
proc version(packet: Packet): uint32 =
|
||||
case packet.kind
|
||||
of packetInitial: packet.initial.version
|
||||
of packet0RTT: packet.rtt.version
|
||||
of packetHandshake: packet.handshake.version
|
||||
of packetRetry: packet.retry.version
|
||||
of packetVersionNegotiation: 0
|
||||
|
||||
proc writeVersion*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
writer.write(datagram, toBytesBE(writer.packet.version))
|
||||
|
||||
proc writeConnectionId(
|
||||
writer: var PacketWriter, datagram: var openArray[byte], id: ConnectionId
|
||||
) =
|
||||
let bytes = cast[seq[byte]](id)
|
||||
writer.write(datagram, @[bytes.len.uint8] & bytes)
|
||||
|
||||
proc writeDestination*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
writer.writeConnectionId(datagram, writer.packet.destination)
|
||||
|
||||
proc writeSource*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
writer.writeConnectionId(datagram, writer.packet.source)
|
||||
|
||||
proc writeSupportedVersions*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
for version in writer.packet.negotiation.supportedVersions:
|
||||
writer.write(datagram, version.toBytesBE)
|
||||
|
||||
proc `token`(packet: Packet): seq[byte] =
|
||||
case packet.kind
|
||||
of packetInitial:
|
||||
packet.initial.token
|
||||
of packetRetry:
|
||||
packet.retry.token
|
||||
else:
|
||||
@[]
|
||||
|
||||
proc writeTokenLength*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
writer.write(datagram, writer.packet.token.len.toVarInt)
|
||||
|
||||
proc writeToken*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
writer.write(datagram, writer.packet.token)
|
||||
|
||||
proc writeIntegrity*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
writer.write(datagram, writer.packet.retry.integrity)
|
||||
|
||||
proc payload(packet: Packet): seq[byte] =
|
||||
case packet.form
|
||||
of formShort:
|
||||
packet.short.payload
|
||||
of formLong:
|
||||
case packet.kind
|
||||
of packetHandshake:
|
||||
packet.handshake.payload
|
||||
of packet0RTT:
|
||||
packet.rtt.payload
|
||||
of packetInitial:
|
||||
packet.initial.payload
|
||||
else:
|
||||
@[]
|
||||
|
||||
proc writePacketLength(
|
||||
writer: var PacketWriter, datagram: var openArray[byte], length: VarIntCompatible
|
||||
) =
|
||||
case writer.packet.form
|
||||
of formLong:
|
||||
writer.write(datagram, length.toVarInt)
|
||||
of formShort:
|
||||
discard
|
||||
|
||||
proc packetNumber(packet: Packet): PacketNumber =
|
||||
case packet.form
|
||||
of formShort:
|
||||
packet.short.packetnumber
|
||||
of formLong:
|
||||
case packet.kind
|
||||
of packetHandshake: packet.handshake.packetnumber
|
||||
of packet0RTT: packet.rtt.packetnumber
|
||||
of packetInitial: packet.initial.packetnumber
|
||||
else: 0
|
||||
|
||||
proc writePacketNumber(
|
||||
writer: var PacketWriter,
|
||||
datagram: var openArray[byte],
|
||||
packetnumber: openArray[byte],
|
||||
) =
|
||||
datagram[writer.first] = datagram[writer.first] or uint8(packetnumber.len - 1)
|
||||
writer.write(datagram, packetnumber)
|
||||
|
||||
proc writePacketNumberAndPayload*(
|
||||
writer: var PacketWriter, datagram: var openArray[byte]
|
||||
) =
|
||||
let packetnumber = writer.packet.packetNumber.toMinimalBytes
|
||||
let payload = writer.packet.payload
|
||||
writer.writePacketLength(datagram, packetnumber.len + payload.len)
|
||||
writer.writePacketNumber(datagram, packetnumber)
|
||||
writer.write(datagram, payload)
|
||||
|
||||
proc writeSpinBit*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
datagram[writer.next].bits[2] = Bit(writer.packet.short.spinBit)
|
||||
|
||||
proc writeReservedBits*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
datagram[writer.next].bits[3] = 0
|
||||
datagram[writer.next].bits[4] = 0
|
||||
|
||||
proc writeKeyPhase*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
datagram[writer.next].bits[5] = Bit(writer.packet.short.keyPhase)
|
||||
writer.move(1)
|
||||
|
||||
proc writeShortDestination*(writer: var PacketWriter, datagram: var openArray[byte]) =
|
||||
writer.write(datagram, cast[seq[byte]](writer.packet.destination))
|
||||
@@ -1,22 +0,0 @@
|
||||
import ../../helpers/openarray
|
||||
import ./packet
|
||||
|
||||
type PacketWriter* = object
|
||||
packet*: Packet
|
||||
first*, next*: int
|
||||
|
||||
proc move*(writer: var PacketWriter, amount: int) =
|
||||
writer.next = writer.next + amount
|
||||
|
||||
proc write*(
|
||||
writer: var PacketWriter, datagram: var openArray[byte], bytes: openArray[byte]
|
||||
) =
|
||||
datagram[writer.next ..< writer.next + bytes.len] = bytes
|
||||
writer.move(bytes.len)
|
||||
|
||||
proc nextPacket*(writer: var PacketWriter, packet: Packet) =
|
||||
writer.packet = packet
|
||||
writer.first = writer.next
|
||||
|
||||
proc bytesWritten*(writer: PacketWriter): int =
|
||||
writer.next
|
||||
@@ -7,7 +7,7 @@ import pkg/stew/endians2
|
||||
import ../helpers/simulation
|
||||
|
||||
const
|
||||
runs = 1
|
||||
runs = 10
|
||||
uploadSize = 100000 # 100KB
|
||||
downloadSize = 100000000 # 100MB
|
||||
chunkSize = 65536 # 64KB chunks like perf
|
||||
|
||||
Reference in New Issue
Block a user