public void SendPreparedPacket(IOutOctetStream reference)
{
var octetsToSend = pendingOutOctetStream.Close();
var now = monotonicClock.NowMilliseconds();
if (pendingOutSequenceNumberUsed)
{
outStatsCollector.SequencePacketSent(pendingOutSequenceNumber.Value, now, octetsToSend.Length);
}
else
{
outStatsCollector.PacketSent(now, octetsToSend.Length);
}
simpleOut.AddPacket(octetsToSend.Length);
if (octetsToSend.Length > 0)
{
if (useDebugLogging)
{
log.Trace($"Sending packet {ByteArrayToString(octetsToSend)}");
}
udpClient.Send(octetsToSend);
lastSentPackets = monotonicClock.NowMilliseconds();
}
else
{
if (useDebugLogging)
{
log.Trace($"Strange nothing to send");
}
}
}
void RequestTime(IOutOctetStream outStream)
{
var now = monotonicClock.NowMilliseconds();
var timeSyncRequest = new TimeSyncRequest(now);
TimeSyncRequestSerializer.Serialize(outStream, timeSyncRequest);
}
public static void Serialize(IOutOctetStream stream, string value)
{
var octets = Encoding.UTF8.GetBytes(value);
stream.WriteUint8((byte)octets.Length);
stream.WriteOctets(octets);
}
public bool WriteUpdatePayload(IOutOctetStream octetStream)
{
var canSendUpdatePacket = tendOut.CanIncrementOutgoingSequence;
pendingOutSequenceNumberUsed = false;
if (canSendUpdatePacket)
{
outgoingSequenceNumber = outgoingSequenceNumber.Next();
pendingOutSequenceNumber = outgoingSequenceNumber;
pendingOutSequenceNumberUsed = true;
var tendSequenceId = tendOut.IncreaseOutgoingSequenceId();
WriteHeader(octetStream, NormalMode, outgoingSequenceNumber.Value, connectionId);
TendSerializer.Serialize(octetStream, tendIn, tendOut);
var now = monotonicClock.NowMilliseconds();
timestampedHistory.SentPacket(outgoingSequenceNumber, now, log);
if (useDebugLogging)
{
log.Trace($"SendOneUpdatePacket: tendSeq{tendSequenceId}");
}
return(true);
}
WritePing(octetStream);
return(false);
}
void WritePing(IOutOctetStream outStream)
{
var now = monotonicClock.NowMilliseconds();
var pingRequest = new PingRequestHeader(now);
PingRequestHeaderSerializer.Serialize(outStream, pingRequest);
TendSerializer.Serialize(outStream, tendIn, tendOut);
}
public static void Serialize(IOutOctetStream stream, ConnectInfo cmd)
{
NameVersionSerializer.Serialize(stream, cmd.BriskVersion);
NameVersionSerializer.Serialize(stream, cmd.SdkVersion);
NameVersionSerializer.Serialize(stream, cmd.SchemaVersion);
NameVersionSerializer.Serialize(stream, cmd.ApplicationVersion);
PayloadSerializer.Serialize(stream, cmd.Payload);
}
public static void Serialize(IOutOctetStream stream, ConnectRequest cmd)
{
stream.WriteUint8(CommandValues.ConnectRequest);
stream.WriteUint32(cmd.MyNonce);
stream.WriteUint32(cmd.RemoteNonce);
UniqueSessionIdSerializer.Serialize(stream, cmd.SessionId);
ConnectInfoSerializer.Serialize(stream, cmd.Info);
}
public static void Serialize(IOutOctetStream stream, IncomingLogic tendIn, OutgoingLogic tendOut)
{
stream.WriteUint8(tendOut.OutgoingSequenceId.Value);
var header = tendIn.ReceivedHeader;
stream.WriteUint8(header.SequenceId.Value);
stream.WriteUint32(header.ReceivedBits.Bits);
}
void SendChallenge(IOutOctetStream outStream)
{
var challenge = new ChallengeRequest(challengeNonce);
if (useDebugLogging)
{
log.Debug($"Sending Challenge {challenge}");
}
ChallengeRequestSerializer.Serialize(outStream, challenge);
lastStateChange = monotonicClock.NowMilliseconds();
stateChangeWait = 500;
}
void SendConnectRequest(IOutOctetStream outStream)
{
var request = new ConnectRequest(remoteNonce, challengeNonce, sessionId, connectInfo);
if (useDebugLogging)
{
log.Debug($"Sending Connect request {request}");
}
ConnectRequestSerializer.Serialize(outStream, request);
lastStateChange = monotonicClock.NowMilliseconds();
stateChangeWait = 500;
}
public (IOutOctetStream, SequenceId, bool) PreparePacket()
{
var octetStream = new OutOctetStream();
pendingOutOctetStream = octetStream;
var wasUpdate = false;
switch (state)
{
case ConnectionState.Challenge:
WriteHeader(octetStream, OobMode, outSequenceNumber++, 0);
SendChallenge(octetStream);
break;
case ConnectionState.TimeSync:
WriteHeader(octetStream, OobMode, outSequenceNumber++, connectionId);
SendTimeSync(octetStream);
break;
case ConnectionState.ConnectRequest:
WriteHeader(octetStream, OobMode, outSequenceNumber++, 0);
SendConnectRequest(octetStream);
break;
case ConnectionState.Connected:
wasUpdate = WriteUpdatePayload(octetStream);
break;
case ConnectionState.Disconnected:
break;
case ConnectionState.Idle:
break;
default:
throw new ArgumentOutOfRangeException("unknown state");
}
var streamToReturn = wasUpdate ? octetStream : null;
return(streamToReturn, pendingOutSequenceNumber, wasUpdate);
}
public static void Serialize(IOutOctetStream stream, ChallengeRequest cmd)
{
stream.WriteUint8(CommandValues.ChallengeRequest);
stream.WriteUint32(cmd.Nonce);
}
public static void Serialize(IOutOctetStream stream, PingRequestHeader cmd)
{
stream.WriteUint8(CommandValues.PingRequest);
stream.WriteUint64((ushort)cmd.LocalElapsedMilliseconds);
}
public static void Serialize(IOutOctetStream stream, UniqueSessionID sessionId)
{
stream.WriteUint8((byte)sessionId.Value.Length);
stream.WriteOctets(sessionId.Value);
}
public static void Serialize(IOutOctetStream stream, CustomConnectPayload payload)
{
stream.WriteUint8((byte)payload.Payload.Length);
stream.WriteOctets(payload.Payload);
}
public static void Serialize(IOutOctetStream stream, Version version)
{
stream.WriteUint16(version.Major);
stream.WriteUint16(version.Minor);
stream.WriteUint16(version.Patch);
}
static void WriteHeader(IOutOctetStream outStream, byte mode, byte sequence, ushort connectionIdToSend)
{
outStream.WriteUint8(mode);
outStream.WriteUint8(sequence);
outStream.WriteUint16(connectionIdToSend);
}
public static void Serialize(IOutOctetStream stream, NameVersion nameVersion)
{
StringSerializer.Serialize(stream, nameVersion.Name);
VersionSerializer.Serialize(stream, nameVersion.Version);
}
public void SendTimeSync(IOutOctetStream outStream)
{
// log.Trace("Sending TimeSync!");
RequestTime(outStream);
}
