public override void Start(int rate)
{
base.Start(rate);
window = new GameWindow();
window.Visible = true;
Uri shader = new Uri("shader://FileSystemMod/effects/basic30.effect");
renderer = new GL30BatchVertexRenderer();
/*
renderer.ActiveShader = sh;
renderer.ActiveShader["Proj"] = Matrix4.Identity;
renderer.ActiveShader["View"] = Matrix4.Identity;
*/
window.KeyPress += new EventHandler<KeyPressEventArgs>(window_KeyPress);
int port = 2861;
Util.Msg("Starting Client");
NetPeerConfiguration config = new NetPeerConfiguration(Watertight.ImplName + Watertight.Version);
config.Port = port + 1;
config.UseMessageRecycling = true;
NetClient client = new NetClient(config);
client.Start();
NetOutgoingMessage connectMessage = client.CreateMessage();
ConnectPacket connect = new ConnectPacket();
connect.Encode(ref connectMessage);
client.Connect("localhost", port, connectMessage);
Simulation.LuaComponent lc = Simulation.EntityComponentDictionary.NewComponent("TestLuaComponent") as Simulation.LuaComponent;
foreach (Mod m in ModManager.Mods())
{
m.ResourceLoad();
}
RunGameLoop();
}
Packet DecodePacketInternal(IByteBuffer buffer, int packetSignature, ref int remainingLength, IChannelHandlerContext context)
{
if (Signatures.IsPublish(packetSignature))
{
var qualityOfService = (QualityOfService)((packetSignature >> 1) & 0x3); // take bits #1 and #2 ONLY and convert them into QoS value
if (qualityOfService == QualityOfService.Reserved)
{
ThrowHelper.ThrowDecoderException_UnexpectedQoSValueForPublish(qualityOfService);
}
bool duplicate = (packetSignature & 0x8) == 0x8; // test bit#3
bool retain = (packetSignature & 0x1) != 0; // test bit#0
var packet = new PublishPacket(qualityOfService, duplicate, retain);
DecodePublishPacket(buffer, packet, ref remainingLength);
return(packet);
}
switch (packetSignature) // strict match checks for valid message type + correct values in flags part
{
case Signatures.PubAck:
var pubAckPacket = new PubAckPacket();
DecodePacketIdVariableHeader(buffer, pubAckPacket, ref remainingLength);
return(pubAckPacket);
case Signatures.PubRec:
var pubRecPacket = new PubRecPacket();
DecodePacketIdVariableHeader(buffer, pubRecPacket, ref remainingLength);
return(pubRecPacket);
case Signatures.PubRel:
var pubRelPacket = new PubRelPacket();
DecodePacketIdVariableHeader(buffer, pubRelPacket, ref remainingLength);
return(pubRelPacket);
case Signatures.PubComp:
var pubCompPacket = new PubCompPacket();
DecodePacketIdVariableHeader(buffer, pubCompPacket, ref remainingLength);
return(pubCompPacket);
case Signatures.PingReq:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
return(PingReqPacket.Instance);
case Signatures.Subscribe:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var subscribePacket = new SubscribePacket();
DecodePacketIdVariableHeader(buffer, subscribePacket, ref remainingLength);
DecodeSubscribePayload(buffer, subscribePacket, ref remainingLength);
return(subscribePacket);
case Signatures.Unsubscribe:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var unsubscribePacket = new UnsubscribePacket();
DecodePacketIdVariableHeader(buffer, unsubscribePacket, ref remainingLength);
DecodeUnsubscribePayload(buffer, unsubscribePacket, ref remainingLength);
return(unsubscribePacket);
case Signatures.Connect:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
var connectPacket = new ConnectPacket();
DecodeConnectPacket(buffer, connectPacket, ref remainingLength, context);
return(connectPacket);
case Signatures.Disconnect:
if (!_isServer)
{
ValidateServerPacketExpected(packetSignature);
}
return(DisconnectPacket.Instance);
case Signatures.ConnAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var connAckPacket = new ConnAckPacket();
DecodeConnAckPacket(buffer, connAckPacket, ref remainingLength);
return(connAckPacket);
case Signatures.SubAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var subAckPacket = new SubAckPacket();
DecodePacketIdVariableHeader(buffer, subAckPacket, ref remainingLength);
DecodeSubAckPayload(buffer, subAckPacket, ref remainingLength);
return(subAckPacket);
case Signatures.UnsubAck:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
var unsubAckPacket = new UnsubAckPacket();
DecodePacketIdVariableHeader(buffer, unsubAckPacket, ref remainingLength);
return(unsubAckPacket);
case Signatures.PingResp:
if (_isServer)
{
ValidateClientPacketExpected(packetSignature);
}
return(PingRespPacket.Instance);
default:
return(ThrowHelper.ThrowDecoderException_FirstPacketByteValueIsInvalid(packetSignature));
}
}
static void DecodeConnectPacket(IByteBuffer buffer, ConnectPacket packet, ref int remainingLength, IChannelHandlerContext context)
{
string protocolName = DecodeString(buffer, ref remainingLength);
if (!string.Equals(Util.ProtocolName, protocolName
#if NETCOREAPP_3_0_GREATER || NETSTANDARD_2_0_GREATER
))
#else
, StringComparison.Ordinal))
#endif
{
ThrowHelper.ThrowDecoderException_UnexpectedProtocolName(protocolName);
}
packet.ProtocolName = Util.ProtocolName;
DecreaseRemainingLength(ref remainingLength, 1);
packet.ProtocolLevel = buffer.ReadByte();
if (packet.ProtocolLevel != Util.ProtocolLevel)
{
var connAckPacket = new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedUnacceptableProtocolVersion
};
context.WriteAndFlushAsync(connAckPacket);
ThrowHelper.ThrowDecoderException_UnexpectedProtocolLevel(packet.ProtocolLevel);
}
DecreaseRemainingLength(ref remainingLength, 1);
int connectFlags = buffer.ReadByte();
packet.CleanSession = (connectFlags & 0x02) == 0x02;
bool hasWill = (connectFlags & 0x04) == 0x04;
if (hasWill)
{
packet.HasWill = true;
packet.WillRetain = (connectFlags & 0x20) == 0x20;
var willQualityOfService = packet.WillQualityOfService = (QualityOfService)((connectFlags & 0x18) >> 3);
if (willQualityOfService == QualityOfService.Reserved)
{
ThrowHelper.ThrowDecoderException_UnexpectedWillQoSValueOf(willQualityOfService);
}
packet.WillTopicName = string.Empty;
}
else if ((connectFlags & 0x38) != 0) // bits 3,4,5 [MQTT-3.1.2-11]
{
ThrowHelper.ThrowDecoderException_MQTT_312_11();
}
packet.HasUsername = (connectFlags & 0x80) == 0x80;
packet.HasPassword = (connectFlags & 0x40) == 0x40;
if (packet.HasPassword && !packet.HasUsername)
{
ThrowHelper.ThrowDecoderException_MQTT_312_22();
}
if ((connectFlags & 0x1) != 0) // [MQTT-3.1.2-3]
{
ThrowHelper.ThrowDecoderException_MQTT_312_3();
}
packet.KeepAliveInSeconds = DecodeUnsignedShort(buffer, ref remainingLength);
string clientId = DecodeString(buffer, ref remainingLength);
if (clientId is null)
{
Util.ValidateClientId();
}
packet.ClientId = clientId;
if (hasWill)
{
packet.WillTopicName = DecodeString(buffer, ref remainingLength);
int willMessageLength = DecodeUnsignedShort(buffer, ref remainingLength);
DecreaseRemainingLength(ref remainingLength, willMessageLength);
packet.WillMessage = buffer.ReadBytes(willMessageLength);
}
if (packet.HasUsername)
{
packet.Username = DecodeString(buffer, ref remainingLength);
}
if (packet.HasPassword)
{
packet.Password = DecodeString(buffer, ref remainingLength);
}
}
private bool v_DefaultAuth(ConnectPacket packet)
{
return(Network.ShouldAuthWhenDefault);
}
/// <summary>
/// Performs complete initialization of <see cref="MqttAdapter" /> based on received CONNECT packet.
/// </summary>
/// <param name="context"><see cref="IChannelHandlerContext" /> instance.</param>
/// <param name="packet">CONNECT packet.</param>
async void Connect(IChannelHandlerContext context, ConnectPacket packet)
{
bool connAckSent = false;
Exception exception = null;
try
{
if (!this.IsInState(StateFlags.WaitingForConnect))
{
ShutdownOnError(context, ConnectProcessingScope, new InvalidOperationException("CONNECT has been received in current session already. Only one CONNECT is expected per session."));
return;
}
this.stateFlags = StateFlags.ProcessingConnect;
this.identity = await this.authProvider.GetAsync(packet.ClientId,
packet.Username, packet.Password, context.Channel.RemoteAddress);
if (!this.identity.IsAuthenticated)
{
CommonEventSource.Log.Info("ClientNotAuthenticated", $"Client ID: {packet.ClientId}; Username: {packet.Username}", this.ChannelId);
connAckSent = true;
await Util.WriteMessageAsync(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedNotAuthorized
});
PerformanceCounters.ConnectionFailedAuthPerSecond.Increment();
ShutdownOnError(context, ConnectProcessingScope, new AuthenticationException("Authentication failed."));
return;
}
CommonEventSource.Log.Info("ClientAuthenticated", this.identity.ToString(), this.ChannelId);
this.messagingBridge = await this.messagingBridgeFactory(this.identity);
bool sessionPresent = await this.EstablishSessionStateAsync(packet.CleanSession);
this.keepAliveTimeout = this.DeriveKeepAliveTimeout(context, packet);
if (packet.HasWill)
{
var will = new PublishPacket(packet.WillQualityOfService, false, packet.WillRetain);
will.TopicName = packet.WillTopicName;
will.Payload = packet.WillMessage;
this.willPacket = will;
}
connAckSent = true;
await Util.WriteMessageAsync(context, new ConnAckPacket
{
SessionPresent = sessionPresent,
ReturnCode = ConnectReturnCode.Accepted
});
this.CompleteConnect(context);
}
catch (Exception ex)
{
exception = ex;
}
if (exception != null)
{
if (!connAckSent)
{
try
{
await Util.WriteMessageAsync(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedServerUnavailable
});
}
catch (Exception ex)
{
if (CommonEventSource.Log.IsVerboseEnabled)
{
CommonEventSource.Log.Verbose("Error sending 'Server Unavailable' CONNACK.", ex.ToString(), this.ChannelId);
}
}
}
ShutdownOnError(context, ConnectProcessingScope, exception);
}
}
public void ConnectPacket(string userName)
{
ConnectPacket packet = new ConnectPacket(userName + "#" + ID);
SendPacket(packet);
}
public abstract void Login(IChannelHandlerContext context, ConnectPacket packet);
public async Task Login(IChannelHandlerContext context, ConnectPacket packet)
{
string deviceId = packet.ClientId;
var message = TransportMessage.CreateInvokeMessage(new RemoteInvokeMessage()
{
ServiceId = $"Connect", Parameters = new Dictionary <string, object> {
{ "packet", packet }
}
});
WirteDiagnosticBefore(message, context.Channel.RemoteAddress.ToString(), deviceId, packet.PacketType);
if (string.IsNullOrEmpty(deviceId))
{
await ConnAck(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedIdentifierRejected
});
return;
}
var mqttBehavior = _mqttBehaviorProvider.GetMqttBehavior();
if (mqttBehavior != null)
{
if (packet.HasPassword && packet.HasUsername &&
await mqttBehavior.Authorized(packet.Username, packet.Password))
{
var mqttChannel = _channelService.GetMqttChannel(deviceId);
if (mqttChannel == null || !await mqttChannel.IsOnine())
{
byte[] bytes = null;
if (packet.WillMessage != null)
{
bytes = new byte[packet.WillMessage.ReadableBytes];
packet.WillMessage.ReadBytes(bytes);
}
await _channelService.Login(context.Channel, deviceId, new ConnectMessage
{
CleanSession = packet.CleanSession,
ClientId = packet.ClientId,
Duplicate = packet.Duplicate,
HasPassword = packet.HasPassword,
HasUsername = packet.HasUsername,
HasWill = packet.HasWill,
KeepAliveInSeconds = packet.KeepAliveInSeconds,
Password = packet.Password,
ProtocolLevel = packet.ProtocolLevel,
ProtocolName = packet.ProtocolName,
Qos = (int)packet.QualityOfService,
RetainRequested = packet.RetainRequested,
Username = packet.Username,
WillMessage = bytes,
WillQualityOfService = (int)packet.WillQualityOfService,
WillRetain = packet.WillRetain,
WillTopic = packet.WillTopicName
});
}
}
else
{
await ConnAck(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedBadUsernameOrPassword
});
}
}
else
{
await ConnAck(context, new ConnAckPacket
{
ReturnCode = ConnectReturnCode.RefusedServerUnavailable
});
}
WirteDiagnosticAfter(message);
}
public static Packet DecodePacket(DataReader reader)
{
reader.ByteOrder = ByteOrder.BigEndian;
int signature = reader.ReadByte();
int remainingLength = DecodeRemainingLength(reader);
if (Signatures.IsPublish(signature))
{
var qualityOfService =
(QualityOfService)((signature >> 1) &
0x3); // take bits #1 and #2 ONLY and convert them into QoS value
if (qualityOfService == QualityOfService.Reserved)
{
throw new Exception(
$"Unexpected QoS value of {(int)qualityOfService} for {PacketType.PUBLISH} packet.");
}
bool duplicate = (signature & 0x8) == 0x8; // test bit#3
bool retain = (signature & 0x1) != 0; // test bit#0
var packet = new PublishPacket(qualityOfService, duplicate, retain);
DecodePublishPacket(reader, packet, ref remainingLength);
return(packet);
}
switch (signature & 240) // We don't care about flags for these packets
{
// case Signatures.Subscribe & 240:
// var subscribePacket = new SubscribePacket();
// DecodePacketIdVariableHeader(reader, subscribePacket, ref remainingLength);
// DecodeSubscribePayload(buffer, subscribePacket, ref remainingLength);
// return subscribePacket;
case Signatures.Connect:
var connectPacket = new ConnectPacket();
DecodeConnectPacket(reader, connectPacket, ref remainingLength);
return(connectPacket);
case Signatures.PubAck:
var pubAckPacket = new PubAckPacket();
DecodePacketIdVariableHeader(reader, pubAckPacket, ref remainingLength);
return(pubAckPacket);
case Signatures.ConnAck:
var connAckPacket = new FbnsConnAckPacket();
DecodeConnAckPacket(reader, connAckPacket, ref remainingLength);
return(connAckPacket);
case Signatures.SubAck:
var subAckPacket = new SubAckPacket();
DecodePacketIdVariableHeader(reader, subAckPacket, ref remainingLength);
DecodeSubAckPayload(reader, subAckPacket, ref remainingLength);
return(subAckPacket);
case Signatures.UnsubAck:
var unsubAckPacket = new UnsubAckPacket();
DecodePacketIdVariableHeader(reader, unsubAckPacket, ref remainingLength);
return(unsubAckPacket);
case Signatures.PingResp:
return(PingRespPacket.Instance);
default:
throw new Exception($"Packet type {signature} not supported");
}
}
static void DecodeConnectPacket(DataReader buffer, ConnectPacket packet, ref int remainingLength)
{
string protocolName = DecodeString(buffer, ref remainingLength);
// if (!PROTOCOL_NAME.Equals(protocolName, StringComparison.Ordinal))
// {
// throw new Exception($"Unexpected protocol name. Expected: {PROTOCOL_NAME}. Actual: {protocolName}");
// }
packet.ProtocolName = protocolName;
DecreaseRemainingLength(ref remainingLength, 1);
packet.ProtocolLevel = buffer.ReadByte();
// if (packet.ProtocolLevel != Util.ProtocolLevel)
// {
// var connAckPacket = new ConnAckPacket();
// connAckPacket.ReturnCode = ConnectReturnCode.RefusedUnacceptableProtocolVersion;
// context.WriteAndFlushAsync(connAckPacket);
// throw new Exception($"Unexpected protocol level. Expected: {Util.ProtocolLevel}. Actual: {packet.ProtocolLevel}");
// }
DecreaseRemainingLength(ref remainingLength, 1);
int connectFlags = buffer.ReadByte();
packet.CleanSession = (connectFlags & 0x02) == 0x02;
bool hasWill = (connectFlags & 0x04) == 0x04;
if (hasWill)
{
packet.HasWill = true;
packet.WillRetain = (connectFlags & 0x20) == 0x20;
packet.WillQualityOfService = (QualityOfService)((connectFlags & 0x18) >> 3);
if (packet.WillQualityOfService == QualityOfService.Reserved)
{
throw new Exception($"[MQTT-3.1.2-14] Unexpected Will QoS value of {(int)packet.WillQualityOfService}.");
}
packet.WillTopicName = string.Empty;
}
else if ((connectFlags & 0x38) != 0) // bits 3,4,5 [MQTT-3.1.2-11]
{
throw new Exception("[MQTT-3.1.2-11]");
}
packet.HasUsername = (connectFlags & 0x80) == 0x80;
packet.HasPassword = (connectFlags & 0x40) == 0x40;
if (packet.HasPassword && !packet.HasUsername)
{
throw new Exception("[MQTT-3.1.2-22]");
}
if ((connectFlags & 0x1) != 0) // [MQTT-3.1.2-3]
{
throw new Exception("[MQTT-3.1.2-3]");
}
packet.KeepAliveInSeconds = DecodeUnsignedShort(buffer, ref remainingLength);
string clientId = DecodeString(buffer, ref remainingLength);
if (string.IsNullOrEmpty(clientId))
{
throw new Exception("Client identifier is required.");
}
packet.ClientId = clientId;
if (hasWill)
{
packet.WillTopicName = DecodeString(buffer, ref remainingLength);
var willMessageLength = DecodeUnsignedShort(buffer, ref remainingLength);
DecreaseRemainingLength(ref remainingLength, willMessageLength);
packet.WillMessage = buffer.ReadBuffer(willMessageLength);
}
if (packet.HasUsername)
{
packet.Username = DecodeString(buffer, ref remainingLength);
}
if (packet.HasPassword)
{
packet.Password = DecodeString(buffer, ref remainingLength);
}
}
