public NetworkPacket()
{
PublicKeySource = new Hash();
Type = PacketType.TPT_NOTHING;
Data = new byte[0];
Token = new Hash();
}
protected FunctionServiceResult ProcessReadRegisters(Sample[] samples, PacketType? packetType)
{
//Get the raw bytes
var messageBytes = samples
.Select(s => s.Value)
.ToArray();
//We'll assume that this is a response
byte numberOfBytes = messageBytes[2];
//Get the number of registers
var numberOfRegisters = numberOfBytes / 2;
//Get the registers themselves
var registers = GetRegisters(messageBytes, numberOfRegisters, 3);
//Create the visual factory
Func<Visual> visualFactory = () =>
{
var viewModel = new RegistersViewModel(registers);
return new RegistersView()
{
DataContext = viewModel
};
};
var summary = $"{numberOfRegisters} registers.";
return new FunctionServiceResult(summary, visualFactory, packetType);
}
public static RequestPacket PackRequest(PacketType packetType, string arg1)
{
if (arg1 == null)
throw new ArgumentNullException("arg1");
return new RequestPacket(packetType, Encoding.UTF8.GetBytes(arg1));
}
public NetworkPacket(Hash publicKey_Src, PacketType type, byte[] Data, Hash token)
{
PublicKeySource = publicKey_Src;
Type = type;
this.Data = Data;
Token = token;
}
public static void Write(this Buffer buffer, PacketType type, byte[] data)
{
buffer.Reset(0);
buffer.WriteByte((byte)type);
buffer.WriteBytes(data);
buffer.WriteSum();
}
public Packet(PacketType pType, PacketClient client, bool ClientProtocolPacket, PacketArguments args)
{
PacketArgs = args;
sock = client;
PacketArgs.packetType = pType;
PacketArgs.ClientPacket = ClientProtocolPacket;
}
public OutPacket(PacketType type)
: base(type)
{
writer = new StreamWriter(stream);
Write((ushort)0); // Will be replaced w/ length later. (Will be content size).
Write((ushort)Id); // Writes the id to the packet.
}
public Packet(string verb, string parameter, Connection client)
{
Client = client;
packetType = PacketType.verb;
this.verb = verb;
this.parameter = parameter;
}
public SystemEventPacket(EventType eventType, string message, Connection client = null)
{
Client = client;
packetType = PacketType.system;
this.eventType = eventType;
this.message = message;
}
public ClientPacketHandler(PacketType type, int length, int minimumLength, OnPacketReceive onReceive)
{
_packetId = type;
_length = length;
_minimumLength = minimumLength;
_onReceive = onReceive;
}
public EventData(PacketType packetType, PluginHandle target, BotEventHandler eventHandler, BotEventHandlerAttribute attribute)
{
Target = target;
PacketType = packetType;
EventHandler = eventHandler;
Attribute = attribute;
}
public void OnDisconnect(ref PacketReader _pReader, PacketType pt, ref ClientManager _client)
{
GridServer.player_list[_client.id]._client.Close();
GridServer.player_list[_client.id]._stream.Close();
GridServer.player_list[_client.id] = null;
_client.Stop(true);
}
public PacketOut(RealmOp op)
{
type = PacketType.RealmPacket;
Write((UInt16) 0); //size
Write((UInt16) op); //op
}
public ServerOperationEventArgs(int SenderID, PacketType PacketType, byte[] Data)
: base()
{
this.senderID = SenderID;
this.packetType = PacketType;
this.data = Data;
}
/// <summary>
/// Fire the events registered for this packet type asynchronously
/// </summary>
/// <param name="packetType">Incoming packet type</param>
/// <param name="packet">Incoming packet</param>
/// <param name="agent">Agent this packet was received from</param>
internal void BeginRaiseEvent(PacketType packetType, Packet packet, Agent agent)
{
UDPServer.PacketCallback callback;
PacketCallbackWrapper wrapper;
// Default handler first, if one exists
if (_EventTable.TryGetValue(PacketType.Default, out callback))
{
if (callback != null)
{
wrapper.Callback = callback;
wrapper.Packet = packet;
wrapper.Agent = agent;
ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper);
}
}
if (_EventTable.TryGetValue(packetType, out callback))
{
if (callback != null)
{
wrapper.Callback = callback;
wrapper.Packet = packet;
wrapper.Agent = agent;
ThreadPool.QueueUserWorkItem(_ThreadPoolCallback, wrapper);
return;
}
}
if (packetType != PacketType.Default && packetType != PacketType.PacketAck)
{
Logger.DebugLog("No handler registered for packet event " + packetType);
}
}
public PacketHandler(PacketType type, int length, int minimumLength, OnPacketReceive onReceive)
{
_PacketId = type;
_Length = length;
_MinimumLength = minimumLength;
_OnReceive = onReceive;
}
public int GetPacketsReceivedFor(PacketType packetType)
{
if (m_packetsReceived.ContainsKey(packetType))
return m_packetsReceived[packetType];
else
return 0;
}
/// <summary>
/// In this version, the message gets broadcasted to everyone, including the client who
/// initiated the sending of the message.
/// </summary>
/// <param name="recipients"></param>
/// <param name="packetType"></param>
/// <param name="data"></param>
public static void BroadcastMessage(IEnumerable<Client> recipients, PacketType packetType, object data)
{
foreach (var c in recipients)
{
SendMessage(c, packetType, data);
}
}
public Packet(PacketType project, byte clas, ushort command, byte[] data)
{
Project = project;
Class = clas;
Command = command;
Data = data;
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="agent">Reference to the client this packet is destined for</param>
/// <param name="buffer">Serialized packet data. If the flags or sequence number
/// need to be updated, they will be injected directly into this binary buffer</param>
/// <param name="category">Throttling category for this packet</param>
/// <param name="type">Packet type</param>
public OutgoingPacket(LLAgent agent, UDPPacketBuffer buffer, ThrottleCategory category, PacketType type)
{
Agent = agent;
Buffer = buffer;
Category = category;
Type = type;
}
public SerialConfig(string cfg)
{
var parts = cfg.Split(new Char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
this.initialConfig = cfg;
int index = 0;
if (!parts[index].StartsWith("COM"))
{
this.DeviceName = parts[index];
index++;
}
this.PortName = parts[index]; index++;
this.AutoConnect = Boolean.Parse(parts[index]); index++;
this.Speed = UInt32.Parse(parts[index]); index++;
this.DataBits = Byte.Parse(parts[index]); index++;
this.Parity = (Parity)Byte.Parse(parts[index]); index++;
this.StopBits = (StopBits)Byte.Parse(parts[index]); index++;
//this.PacketType = (PacketType)Byte.Parse(parts[index]); index++;
this.RxPacketType = (PacketType)Byte.Parse(parts[index]); index++;
this.TxPacketType = (PacketType)Byte.Parse(parts[index]); index++;
this.PacketType = this.RxPacketType;
if (parts.Length > index)
{
this.ReceiverCRC = Byte.Parse(parts[index]); index++;
this.TransmitterCRC = Byte.Parse(parts[index]); index++;
}
if (parts.Length > index)
{
this.DefaultDeviceAddr = Byte.Parse(parts[index]); index++;
}
}
public void AddPacketHandler(PacketType packetType, Action<PacketReceivedEventArgs> handler)
{
if (!_packetHandlers.ContainsKey(packetType))
_packetHandlers.Add(packetType, new List<Action<PacketReceivedEventArgs>>());
_packetHandlers[packetType].Add(handler);
}
public Packet(PacketType type, int length)
{
Length = length;
Type = type;
_Writer = PacketWriter.CreateInstance(length);
_Writer.Write((byte)Type);
}
public void DeCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Logincrypt crypt;
if (type == PacketType.ClientToLoginserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.LoginserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
if (this.staticCrypt)
{
crypt.staticDecrypt(ref raw, offset, lenght);
this.staticCrypt = false;
if (raw[0 + offset] == 0x00)
{
Console.WriteLine("Got Initpacket");
handleInit(new Bytebuffer(raw));
}
}
else
{
crypt.decrypt(ref raw, offset, lenght);
}
}
public void EnCrypt(ref byte[] raw, int lenght, int offset, PacketType type)
{
Logincrypt crypt;
if (type == PacketType.ClientToLoginserver)
{
crypt = this.clientCrypt;
}
else if (type == PacketType.LoginserverToClient)
{
crypt = this.serverCrypt;
}
else
{
throw new Exception("Wrong PacketType "
+ type.ToString() + " for " + this.ToString());
}
if (this.staticCrypt)
{
crypt.staticEncrypt(ref raw, offset, lenght, (uint)new Random().Next());
enableCrypt();
}
else
{
crypt.encrypt(ref raw, offset, lenght);
}
}
public void Deserialize(byte[] Data)
{
List<ProtocolDataType> PDTs = ProtocolPackager.UnPackRaw(Data);
int cnt = 0;
while (cnt < (int)PDTs.Count)
{
ProtocolDataType PDT = PDTs[cnt++];
switch (PDT.NameType)
{
case 0:
ProtocolPackager.UnpackHash(PDT, 0, out PublicKeySource);
break;
case 1:
byte _type = (byte) PacketType.TPT_NOTHING;
ProtocolPackager.UnpackByte(PDT, 1, ref _type);
Type = (PacketType)_type;
break;
case 2:
ProtocolPackager.UnpackByteVector(PDT, 2, ref this.Data);
break;
case 3:
ProtocolPackager.UnpackHash(PDT, 3, out Token);
break;
}
}
}
protected PacketHandler(PacketType packetType, string sender, List<string> recipients, object data)
{
PacketType = packetType;
Sender = sender;
Recipients = recipients;
Data = data;
}
public void OnCreativeInventoryAction(ref PacketReader _pReader, PacketType pt, ref ClientManager _client)
{
short slot = _pReader.ReadShort();
short item_id = _pReader.ReadShort();
short Quanity = _pReader.ReadShort();
short Damage = _pReader.ReadShort();
}
public NetworkPacket(Hash publicKey_Src, PacketType type, byte[] Data)
{
PublicKeySource = publicKey_Src;
Type = type;
this.Data = Data;
Token = new Hash();
}
public NoPayloadPacket(PacketType type)
: base(type)
{
packetBytes = new byte[3];
packetBytes[0] = (byte)((int)Type);
AppendChecksum(packetBytes);
}
private void ReceiveServerKeys()
{
DataFragment packet = ReceivePacket();
SSH1DataReader reader = new SSH1DataReader(packet);
PacketType pt = reader.ReadPacketType();
if (pt != PacketType.SSH_SMSG_PUBLIC_KEY)
{
throw new SSHException("unexpected SSH SSH1Packet type " + pt, reader.ReadAll());
}
_cInfo._serverinfo = new SSHServerInfo(reader);
_cInfo._hostkey = new RSAPublicKey(_cInfo._serverinfo.host_key_public_exponent, _cInfo._serverinfo.host_key_public_modulus);
//read protocol support parameters
int protocol_flags = reader.ReadInt32();
int supported_ciphers_mask = reader.ReadInt32();
_cInfo.SetSupportedCipherAlgorithms(supported_ciphers_mask);
int supported_authentications_mask = reader.ReadInt32();
//Debug.WriteLine(String.Format("ServerOptions {0} {1} {2}", protocol_flags, supported_ciphers_mask, supported_authentications_mask));
if (reader.Rest > 0)
{
throw new SSHException("data length mismatch", reader.ReadAll());
}
bool found = false;
foreach (CipherAlgorithm a in _param.PreferableCipherAlgorithms)
{
if (a != CipherAlgorithm.Blowfish && a != CipherAlgorithm.TripleDES)
{
continue;
}
else if (a == CipherAlgorithm.Blowfish && (supported_ciphers_mask & (1 << (int)CipherAlgorithm.Blowfish)) == 0)
{
continue;
}
else if (a == CipherAlgorithm.TripleDES && (supported_ciphers_mask & (1 << (int)CipherAlgorithm.TripleDES)) == 0)
{
continue;
}
_cInfo._algorithmForReception = _cInfo._algorithmForTransmittion = a;
found = true;
break;
}
if (!found)
{
throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedX"), "Blowfish/TripleDES"));
}
if (_param.AuthenticationType == AuthenticationType.Password && (supported_authentications_mask & (1 << (int)AuthenticationType.Password)) == 0)
{
throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedPassword")), reader.ReadAll());
}
if (_param.AuthenticationType == AuthenticationType.PublicKey && (supported_authentications_mask & (1 << (int)AuthenticationType.PublicKey)) == 0)
{
throw new SSHException(String.Format(Strings.GetString("ServerNotSupportedRSA")), reader.ReadAll());
}
TraceReceptionEvent(pt, "received server key");
}
public static void EncodeHeader(BinaryWriter writer, PacketType packetType)
{
writer.Write(PacketHeaders.P2PTP);
writer.Write((byte)packetType);
}
public Packet(PacketType type, OPCode opcode, string username, byte[] message) : this(type : type, opcode : opcode, username : username, receiver : "", message : message)
{
}
public Packet ReadPacket()
{
if (_Socket == null)
{
return(null);
}
uint blockSize = _ActiveExchangeContext.CipherClientToServer.BlockSize;
// We must have at least 1 block to read
if (_Socket.Available < blockSize)
{
return(null); // Packet not here
}
byte[] firstBlock = new byte[blockSize];
int bytesRead = _Socket.Receive(firstBlock);
if (bytesRead != blockSize)
{
throw new KSSHServerException(DisconnectReason.SSH_DISCONNECT_CONNECTION_LOST, "Failed to read from socket.");
}
firstBlock = _ActiveExchangeContext.CipherClientToServer.Decrypt(firstBlock);
uint packetLength = 0;
byte paddingLength = 0;
using (ByteReader reader = new ByteReader(firstBlock))
{
// uint32 packet_length
// packet_length
// The length of the packet in bytes, not including 'mac' or the
// 'packet_length' field itself.
packetLength = reader.GetUInt32();
if (packetLength > Packet.MaxPacketSize)
{
throw new KSSHServerException(DisconnectReason.SSH_DISCONNECT_PROTOCOL_ERROR, $"Client tried to send a packet bigger than MaxPacketSize ({Packet.MaxPacketSize} bytes): {packetLength} bytes");
}
// byte padding_length
// padding_length
// Length of 'random padding' (bytes).
paddingLength = reader.GetByte();
}
// byte[n1] payload; n1 = packet_length - padding_length - 1
// payload
// The useful contents of the packet. If compression has been
// negotiated, this field is compressed. Initially, compression
// MUST be "none".
uint bytesToRead = packetLength - blockSize + 4;
byte[] restOfPacket = new byte[bytesToRead];
bytesRead = _Socket.Receive(restOfPacket);
if (bytesRead != bytesToRead)
{
throw new KSSHServerException(DisconnectReason.SSH_DISCONNECT_CONNECTION_LOST, "Failed to read from socket.");
}
restOfPacket = _ActiveExchangeContext.CipherClientToServer.Decrypt(restOfPacket);
uint payloadLength = packetLength - paddingLength - 1;
byte[] fullPacket = firstBlock.Concat(restOfPacket).ToArray();
// Track total bytes read
_TotalBytesTransferred += fullPacket.Length;
byte[] payload = fullPacket.Skip(Packet._PacketHeaderSize).Take((int)(packetLength - paddingLength - 1)).ToArray();
// byte[n2] random padding; n2 = padding_length
// random padding
// Arbitrary-length padding, such that the total length of
// (packet_length || padding_length || payload || random padding)
// is a multiple of the cipher block size or 8, whichever is
// larger. There MUST be at least four bytes of padding. The
// padding SHOULD consist of random bytes. The maximum amount of
// padding is 255 bytes.
// byte[m] mac (Message Authentication Code - MAC); m = mac_length
// mac
// Message Authentication Code. If message authentication has
// been negotiated, this field contains the MAC bytes. Initially,
// the MAC algorithm MUST be "none".
uint packetNumber = GetReceivedPacketNumber();
if (_ActiveExchangeContext.MACAlgorithmClientToServer != null)
{
byte[] clientMac = new byte[_ActiveExchangeContext.MACAlgorithmClientToServer.DigestLength];
bytesRead = _Socket.Receive(clientMac);
if (bytesRead != _ActiveExchangeContext.MACAlgorithmClientToServer.DigestLength)
{
throw new KSSHServerException(DisconnectReason.SSH_DISCONNECT_CONNECTION_LOST, "Failed to read from socket.");
}
var mac = _ActiveExchangeContext.MACAlgorithmClientToServer.ComputeHash(packetNumber, fullPacket);
if (!clientMac.SequenceEqual(mac))
{
throw new KSSHServerException(DisconnectReason.SSH_DISCONNECT_MAC_ERROR, "MAC from client is invalid");
}
}
payload = _ActiveExchangeContext.CompressionClientToServer.Decompress(payload);
using (ByteReader packetReader = new ByteReader(payload))
{
PacketType type = (PacketType)packetReader.GetByte();
if (Packet._PacketTypes.ContainsKey(type))
{
Packet packet = Activator.CreateInstance(Packet._PacketTypes[type]) as Packet;
packet.Load(packetReader);
packet.PacketSequence = packetNumber;
return(packet);
}
_Logger.LogWarning($"Unimplemented packet type: {type}");
Unimplemented unimplemented = new Unimplemented()
{
RejectedPacketNumber = packetNumber
};
Send(unimplemented);
}
return(null);
}
public RawPacket(ushort sequence, PacketType type)
{
Sequence = sequence;
_type = type;
}
private async Task <RadioPacket> ExchangePackets(RadioPacket packet_to_send, PacketType expected_type, int timeout = 10000)
{
int start_time = 0;
Bytes received = null;
Debug.WriteLine($"SEND PKT {packet_to_send}");
while (start_time == 0 || Environment.TickCount - start_time < timeout)
{
try
{
if (this.last_packet_timestamp == 0 || (Environment.TickCount - this.last_packet_timestamp) > 2000)
{
received = await RileyLink.SendAndGetPacket(packet_to_send.get_data(), 0, 0, 300, 1, 300);
}
else
{
received = await RileyLink.SendAndGetPacket(packet_to_send.get_data(), 0, 0, 120, 0, 40);
}
}
catch (OmniCoreTimeoutException)
{
received = null;
}
finally
{
if (start_time == 0)
{
start_time = Environment.TickCount;
}
else
{
this.repeated_sends += 1;
}
}
if (received == null)
{
this.receive_timeouts++;
Debug.WriteLine("RECV PKT None");
RileyLink.TxLevelUp();
continue;
}
var p = this.GetPacket(received);
if (p == null)
{
this.bad_packets++;
RileyLink.TxLevelDown();
continue;
}
Debug.WriteLine($"RECV PKT {p}");
if (p.address != this.Pod.RadioAddress)
{
this.bad_packets++;
Debug.WriteLine("RECV PKT ADDR MISMATCH");
RileyLink.TxLevelDown();
continue;
}
this.last_packet_timestamp = Environment.TickCount;
if (this.last_received_packet != null && p.sequence == this.last_received_packet.sequence &&
p.type == this.last_received_packet.type)
{
this.repeated_receives++;
Debug.WriteLine("RECV PKT previous");
RileyLink.TxLevelUp();
continue;
}
this.last_received_packet = p;
this.Pod.PacketSequence = (p.sequence + 1) % 32;
if (p.type != expected_type)
{
Debug.WriteLine("RECV PKT unexpected type");
this.protocol_errors++;
throw new ErosProtocolException("Unexpected packet type received", p);
}
if (p.sequence != (packet_to_send.sequence + 1) % 32)
{
this.Pod.PacketSequence = (p.sequence + 1) % 32;
Debug.WriteLine("RECV PKT unexpected sequence");
this.last_received_packet = p;
this.protocol_errors++;
throw new ErosProtocolException("Incorrect packet sequence received", p);
}
return(p);
}
throw new OmniCoreTimeoutException("Exceeded timeout while send and receive");
}
internal void AsyncReceivePacket(DataFragment data)
{
try {
int len = 0, channel = 0;
SSH1DataReader re = new SSH1DataReader(data);
PacketType pt = re.ReadPacketType();
switch (pt)
{
case PacketType.SSH_SMSG_STDOUT_DATA:
len = re.ReadInt32();
_channel_collection.FindChannelEntry(_shellID).Receiver.OnData(re.Image, re.Offset, len);
break;
case PacketType.SSH_SMSG_STDERR_DATA: {
_channel_collection.FindChannelEntry(_shellID).Receiver.OnExtendedData((int)PacketType.SSH_SMSG_STDERR_DATA, re.ReadString());
}
break;
case PacketType.SSH_MSG_CHANNEL_DATA:
channel = re.ReadInt32();
len = re.ReadInt32();
_channel_collection.FindChannelEntry(channel).Receiver.OnData(re.Image, re.Offset, len);
break;
case PacketType.SSH_MSG_PORT_OPEN:
ProcessPortforwardingRequest(_eventReceiver, re);
break;
case PacketType.SSH_MSG_CHANNEL_CLOSE: {
channel = re.ReadInt32();
ISSHChannelEventReceiver r = _channel_collection.FindChannelEntry(channel).Receiver;
_channel_collection.UnregisterChannelEventReceiver(channel);
r.OnChannelClosed();
}
break;
case PacketType.SSH_MSG_CHANNEL_CLOSE_CONFIRMATION:
channel = re.ReadInt32();
break;
case PacketType.SSH_MSG_DISCONNECT:
_eventReceiver.OnConnectionClosed();
break;
case PacketType.SSH_SMSG_EXITSTATUS:
_channel_collection.FindChannelEntry(_shellID).Receiver.OnChannelClosed();
break;
case PacketType.SSH_MSG_DEBUG:
_eventReceiver.OnDebugMessage(false, re.ReadString());
break;
case PacketType.SSH_MSG_IGNORE:
_eventReceiver.OnIgnoreMessage(re.ReadString());
break;
case PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION: {
int local = re.ReadInt32();
int remote = re.ReadInt32();
_channel_collection.FindChannelEntry(local).Receiver.OnChannelReady();
}
break;
case PacketType.SSH_SMSG_SUCCESS:
if (_executingShell)
{
ExecShell();
_channel_collection.FindChannelEntry(_shellID).Receiver.OnChannelReady();
_executingShell = false;
}
break;
default:
_eventReceiver.OnUnknownMessage((byte)pt, re.ReadAll());
break;
}
}
catch (Exception ex) {
_eventReceiver.OnError(ex);
}
}
private void ConvertData(byte[] bfr, int rcvd)
{
PacketType pkgData;
PacketIP packet = new PacketIP(bfr, rcvd);
ListViewItem item = new ListViewItem();
this.BeginInvoke(new Action(() =>
{
decimal newDataUsage = decimal.Parse(packet.TotalLength) / Mbyte;
DataUsage += newDataUsage;
lblDataUsage.Text = DataUsage.ToString("F2");
File.WriteAllText(generalDataPath + "\\totaldata.txt", DataUsage.ToString());
createAndUpdateDataFolder(newDataUsage);
}));
item.Text = DateTime.Now.ToString("HH:mm:ss:") + DateTime.Now.Millisecond.ToString();
item.SubItems.Add(packet.SourceAddress.ToString());
item.SubItems.Add("0");
item.SubItems.Add(packet.DestinationAddress.ToString());
item.SubItems.Add("0");
item.SubItems.Add(packet.Protocol);
item.SubItems.Add(packet.TotalLength);
switch (packet.Protocol)
{
case "TCP":
PacketTcp tcp = new PacketTcp(packet.Data, packet.MessageLength);
item.SubItems[2].Text = tcp.SourcePort;
item.SubItems[4].Text = tcp.DestinationPort;
pkgData = new PacketType(packet, tcp);
break;
case "UDP":
PacketUdp udp = new PacketUdp(packet.Data, packet.MessageLength);
item.SubItems[2].Text = udp.SourcePort;
item.SubItems[4].Text = udp.DestinationPort;
pkgData = new PacketType(packet, udp);
break;
case "ICMP":
PacketIcmp icmp = new PacketIcmp(packet.Data, packet.MessageLength);
item.SubItems.Add("N/A");
pkgData = new PacketType(packet, icmp);
break;
case "Unknown":
pkgData = new PacketType(packet);
break;
}
if (decimal.Parse(lblDataUsage.Text) > nudDataLimit.Value)
{
System.Diagnostics.Process.Start("ipconfig", "/release");
Stopped = true;
MessageBox.Show("You've reached your data limit!");
}
else
{
//_pkgBuffer.Add(strKey, pkgInfo);
this.BeginInvoke(new Action(() =>
{
lvMessages.Items.Add(item);
}));
}
}
protected override void OnPacketReceived(PacketType packetType, params object[] args)
{
{
var packetArgsCountValidator = new PacketArgsCountValidator();
if (packetArgsCountValidator.Validate(packetType, args.Length) != ErrorCode.Ok)
{
return;
}
}
switch (packetType)
{
case PacketType.GatewayServerAuth:
{
if (!(args[0] is string token))
{
return;
}
if (SubServersContainer.Singleton.GatewayExists(RpcSenderId))
{
return;
}
if (token != OS.GetEnvironment("GATEWAY_TOKEN"))
{
//GD.LogWarn($"Peer {RpcSenderId} sent invalid gateway token.");
DisconnectPeer(RpcSenderId, now: true);
return;
}
//GD.LogInfo("Gateway has been authenticated.");
RemoveTimerForPeer(RpcSenderId);
SubServersContainer.Singleton.AddGateway(RpcSenderId);
break;
}
case PacketType.GameWorldServerAuth:
{
if (!(args[0] is string token))
{
return;
}
if (SubServersContainer.Singleton.GameWorldExists(RpcSenderId))
{
return;
}
if (token != OS.GetEnvironment("GAME_SERVER_TOKEN"))
{
//GD.LogWarn($"Peer {RpcSenderId} sent invalid game server token.");
DisconnectPeer(RpcSenderId, true);
return;
}
//GD.LogInfo("Game Server has been authenticated.");
RemoveTimerForPeer(RpcSenderId);
SubServersContainer.Singleton.AddGameWorld(RpcSenderId);
break;
}
case PacketType.GatewayServerAuthForward:
{
if (!(args[0] is int clientId))
{
return;
}
if (!(args[1] is string login))
{
return;
}
if (!(args[2] is string password))
{
return;
}
DataBase.Singleton.FindUser(RpcSenderId, clientId, login, password); //gateway id too
break;
}
default:
break;
}
}
public static RegistryRegisterBlock GetTransactionRegisterBlock(ulong syncBlockHeight, uint nonce, byte[] powHash, ulong blockHeight, PacketType referencedPacketType,
ushort referencedBlockType, byte[] referencedBlockHash, byte[] referencedTarget, byte[] privateKey)
{
byte[] publicKey = Ed25519.PublicKeyFromSeed(privateKey);
RegistryRegisterBlock transactionRegisterBlock = new RegistryRegisterBlock
{
SyncBlockHeight = syncBlockHeight,
Nonce = nonce,
PowHash = powHash ?? new byte[Globals.POW_HASH_SIZE],
BlockHeight = blockHeight,
ReferencedPacketType = referencedPacketType,
ReferencedBlockType = referencedBlockType,
ReferencedBodyHash = referencedBlockHash,
ReferencedTarget = referencedTarget,
Signer = new Key32(publicKey)
};
return(transactionRegisterBlock);
}
public void SendEvent(PacketType packetType)
{
PacketTransport.SendEvent(netClient.FirstPeer, packetType);
}
public static void Write(this BinaryWriter bw, PacketType packetType)
{
bw.Write(((uint)packetType).ToBigEndian());
}
protected GenericPacket(PacketType type)
{
Type = type;
}
private void ProcessAlgorithmLogsImpl(ConcurrentQueue <string> concurrentQueue, PacketType packetType, int?messageQueueLimit = null)
{
if (concurrentQueue.Count <= 0)
{
return;
}
var result = new List <string>();
var endTime = DateTime.UtcNow.AddMilliseconds(250).Ticks;
string message;
var currentMessageCount = -1;
while (DateTime.UtcNow.Ticks < endTime && concurrentQueue.TryDequeue(out message))
{
if (messageQueueLimit.HasValue)
{
if (currentMessageCount == -1)
{
// this is expensive, so let's get it once
currentMessageCount = Messages.Count;
}
if (currentMessageCount > messageQueueLimit)
{
//if too many in the queue already skip the logging and drop the messages
continue;
}
}
AddToLogStore(message);
result.Add(message);
// increase count after we add
currentMessageCount++;
}
if (result.Count > 0)
{
message = string.Join(Environment.NewLine, result);
if (packetType == PacketType.Debug)
{
Messages.Enqueue(new DebugPacket(ProjectId, AlgorithmId, CompileId, message));
}
else if (packetType == PacketType.Log)
{
Messages.Enqueue(new LogPacket(AlgorithmId, message));
}
else if (packetType == PacketType.HandledError)
{
Messages.Enqueue(new HandledErrorPacket(AlgorithmId, message));
}
}
}
public OutgoingPacket(Simulator simulator, UDPPacketBuffer buffer, PacketType type)
{
Client = simulator;
Buffer = buffer;
this.Type = type;
}
public void recv(ByteChannel channel)
{
cancelCurrentReceive = false;
while (!cancelCurrentReceive)
{
if (packetType == PacketType.NONE)
{
Utils.ensure(recvBuf.limit() >= HEADER_RECV_SZ, ChabuErrorCode.UNKNOWN, "unknown header size: {0}", recvBuf);
channel.read(recvBuf);
if (recvBuf.position() < 8)
{
break;
}
packetSize = recvBuf.getInt(0);
int packetTypeId = recvBuf.getInt(4) & 0xFF;
packetType = PacketTypeExtension.findPacketType(packetTypeId);
if (packetType == PacketType.NONE)
{
throw new ChabuException(string.Format("Packet type 0x{0:X2} unexpected: packetSize {1}", packetTypeId, packetSize));
}
}
if (packetType != PacketType.SEQ)
{
Utils.ensure(packetSize <= Constants.MAX_RECV_LIMIT_LOW, ChabuErrorCode.UNKNOWN, "unknown header size");
if (packetSize > recvBuf.position())
{
recvBuf.limit(packetSize);
channel.read(recvBuf);
if (recvBuf.hasRemaining())
{
// not fully read, try next time
break;
}
}
}
else
{
if (HEADER_RECV_SZ > recvBuf.position())
{
recvBuf.limit(HEADER_RECV_SZ);
channel.read(recvBuf);
if (recvBuf.hasRemaining())
{
// not fully read, try next time
break;
}
}
}
recvBuf.flip();
recvBuf.position(8);
if (packetType != PacketType.SEQ)
{
Utils.ensure(packetSize <= Constants.MAX_RECV_LIMIT_LOW, ChabuErrorCode.UNKNOWN, "unknown header size");
switch (packetType)
{
case PacketType.SETUP: processRecvSetup(); break;
case PacketType.ACCEPT: processRecvAccept(); break;
case PacketType.ABORT: processRecvAbort(); break;
case PacketType.ARM: processRecvArm(); break;
case PacketType.DAVAIL: processRecvDavail(); break;
case PacketType.NOP: processRecvNop(); break;
case PacketType.RST_REQ: processRecvResetReq(); break;
case PacketType.RST_ACK: processRecvResetAck(); break;
default: break;
}
Utils.ensure(recvBuf.remaining() < HEADER_RECV_SZ, ChabuErrorCode.ASSERT, "After normal command, the remaining bytes must be below the HEADER_RECV_SZ limit, but is {0}", recvBuf.limit());
Utils.ensure(recvBuf.position() == packetSize, ChabuErrorCode.ASSERT, "After normal command, the remaining bytes must be below the HEADER_RECV_SZ limit, but is {0}", recvBuf.limit());
recvBuf.compact();
recvBuf.limit(HEADER_RECV_SZ);
packetType = PacketType.NONE;
continue;
}
else
{
processSeq(channel);
bool isContinuingSeq = packetType == PacketType.SEQ;
if (isContinuingSeq)
{
break;
}
continue;
}
}
}
//处理PhyCombine.PacketRecevied_Ev的函数, packet是一个纯包
public void PacketReceviedHdlr(byte[] packet, PacketType ptype)
{
switch (ptype)
{
case PacketType.CORRECT_RESPONSE:
if (validateData(packet, PhyCombine.GetPhyCombine().GetMachineInfo().CrtPctDStart
, PhyCombine.GetPhyCombine().GetMachineInfo().DataWidth,
twoint(packet, PhyCombine.GetPhyCombine().GetMachineInfo().CrtPctVStart)) == true)
{
int seq = Utility.ConvertStrToInt_Big(packet,
PhyCombine.GetPhyCombine().GetMachineInfo().CrtPctSStart,
PhyCombine.GetPhyCombine().GetMachineInfo().SequenceLength);
if (seq > (dots.Count - 1))
{
Console.WriteLine("CORRECT_RESPONSE Error: 纠正序号越界");
return;
}
dots[seq].Rvalue = Utility.ConvertStrToInt_Big(packet,
PhyCombine.GetPhyCombine().GetMachineInfo().CrtPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().DataWidth);
dots[seq].Status = DotStaus.CORRECTED;
if (PacketCorrected_Ev != null)
{
PacketCorrected_Ev(dots[seq], seq);
}
return;
}
else
{
if (PacketStillError_Ev != null)
{
PacketStillError_Ev(Utility.ConvertStrToInt_Big(packet,
PhyCombine.GetPhyCombine().GetMachineInfo().CrtPctSStart,
PhyCombine.GetPhyCombine().GetMachineInfo().SequenceLength));
}
}
break;
case PacketType.DATA_VALUE:
if (validateData(packet, PhyCombine.GetPhyCombine().GetMachineInfo().DataPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().DataWidth, twoint(packet, PhyCombine.GetPhyCombine().GetMachineInfo().DataPctVStart)) == true)
{
dots.Add(new ADot()
{
Rvalue = Utility.ConvertStrToInt_Big(packet, PhyCombine.GetPhyCombine().GetMachineInfo().DataPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().DataWidth),
Status = DotStaus.OK
});
if (PacketRecevied_Ev != null)
{
//通知收到一个包
PacketRecevied_Ev(dots[dots.Count - 1], dots.Count - 1, PacketType.DATA_VALUE);
}
}
else
{
//发生错误
dots.Add(new ADot()
{
Status = DotStaus.CORRECTING,
});
if (PacketCheckError_Ev != null)
{
PacketCheckError_Ev(dots.Count - 1, PacketType.DATA_VALUE);
}
}
break;
case PacketType.RES_COMPUTE_VALUE:
if (validateData(packet, PhyCombine.GetPhyCombine().GetMachineInfo().ResComputePctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().DataWidth, twoint(packet, PhyCombine.GetPhyCombine().GetMachineInfo().ResComputePctVStart)) == true)
{
/*
* dots.Add(new ADot()
* {
* Rvalue = Utility.ConvertStrToInt_Big(packet, PhyCombine.GetPhyCombine().GetMachineInfo().DataPctDStart,
* PhyCombine.GetPhyCombine().GetMachineInfo().DataWidth),
* Status = DotStaus.OK
* });
*/
if (PacketRecevied_Ev != null)
{
//通知收到一个包
PacketRecevied_Ev(null, Utility.ConvertStrToInt_Big(packet, PhyCombine.GetPhyCombine().GetMachineInfo().ResComputePctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().DataWidth), PacketType.RES_COMPUTE_VALUE);
}
}
else
{
//发生错误
if (PacketCheckError_Ev != null)
{
PacketCheckError_Ev(0, PacketType.RES_COMPUTE_VALUE);
}
}
break;
case PacketType.AIR_FLUENT:
if (validateData(packet, PhyCombine.GetPhyCombine().GetMachineInfo().AirFluPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().AirFluPctDataWidth,
twoint(packet, PhyCombine.GetPhyCombine().GetMachineInfo().AirFluPctVStart)) == true)
{
if (PacketRecevied_Ev != null)
{
//通知收到一个包
PacketRecevied_Ev(null, Utility.ConvertStrToInt_Big(packet, PhyCombine.GetPhyCombine().GetMachineInfo().AirFluPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().AirFluPctDataWidth), PacketType.AIR_FLUENT);
}
}
else
{
//发生错误
if (PacketCheckError_Ev != null)
{
PacketCheckError_Ev(0, PacketType.AIR_FLUENT);
}
}
break;
case PacketType.AIR_SAMPLE_TIME:
if (validateData(packet, PhyCombine.GetPhyCombine().GetMachineInfo().AirSTPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().AirSTPctDataWidth,
twoint(packet, PhyCombine.GetPhyCombine().GetMachineInfo().AirSTPctVStart)) == true)
{
if (PacketRecevied_Ev != null)
{
//通知收到一个包
PacketRecevied_Ev(null, Utility.ConvertStrToInt_Big(packet, PhyCombine.GetPhyCombine().GetMachineInfo().AirSTPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().AirSTPctDataWidth), PacketType.AIR_SAMPLE_TIME);
}
}
else
{
//发生错误
if (PacketCheckError_Ev != null)
{
PacketCheckError_Ev(0, PacketType.AIR_SAMPLE_TIME);
}
}
break;
case PacketType.SEQUENCE:
break;
case PacketType.GETSTATUS_RESPONSE:
if (validateData(packet, PhyCombine.GetPhyCombine().GetMachineInfo().GetStatusResPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().GetStatusResPctDataWidth,
twoint(packet, PhyCombine.GetPhyCombine().GetMachineInfo().GetStatusResPctVStart)) == true)
{
if (PacketRecevied_Ev != null)
{
//通知收到一个包, 使用dot传递结果
byte[] statusres_packt_data = new byte[8];
for (int i = 0; i < 8; i++)
{
statusres_packt_data[i] = packet[PhyCombine.GetPhyCombine().GetMachineInfo().GetStatusResPctDStart + i];
}
PacketRecevied_Ev(statusres_packt_data, -1, PacketType.GETSTATUS_RESPONSE);
}
}
else
{
//发生错误
if (PacketCheckError_Ev != null)
{
PacketCheckError_Ev(0, PacketType.GETSTATUS_RESPONSE);
}
}
break;
case PacketType.NORCMD_RESPONSE:
if (validateData(packet, PhyCombine.GetPhyCombine().GetMachineInfo().NorCmdResPctDStart,
PhyCombine.GetPhyCombine().GetMachineInfo().NorCmdResPctDataWidth,
twoint(packet, PhyCombine.GetPhyCombine().GetMachineInfo().NorCmdResPctVStart)) == true)
{
if (PacketRecevied_Ev != null)
{
//通知收到一个包, 使用dot传递结果
byte[] statusres_packt_data = new byte[3];
for (int i = 0; i < 3; i++)
{
statusres_packt_data[i] = packet[PhyCombine.GetPhyCombine().GetMachineInfo().NorCmdResPctDStart + i];
}
PacketRecevied_Ev(statusres_packt_data, -1, PacketType.NORCMD_RESPONSE);
}
}
else
{
//发生错误
if (PacketCheckError_Ev != null)
{
PacketCheckError_Ev(0, PacketType.NORCMD_RESPONSE);
}
}
break;
default:
Console.WriteLine("DataFormater:未知包");
break;
}
}
/// <summary>
/// Channels the write.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="message">The message.</param>
/// <param name="packetType">Type of the packet.</param>
/// <param name="mqttHandlerService">The MQTT handler service.</param>
public async Task ChannelWrite(IChannelHandlerContext context, object message, PacketType packetType,
ServerMqttHandlerService mqttHandlerService)
{
switch (packetType)
{
case PacketType.CONNECT:
await mqttHandlerService.Login(context, message as ConnectPacket);
break;
case PacketType.PUBLISH:
await mqttHandlerService.Publish(context, message as PublishPacket);
break;
case PacketType.PUBACK:
await mqttHandlerService.PubAck(context, message as PubAckPacket);
break;
case PacketType.PUBREC:
await mqttHandlerService.PubRec(context, message as PubRecPacket);
break;
case PacketType.PUBREL:
await mqttHandlerService.PubRel(context, message as PubRelPacket);
break;
case PacketType.PUBCOMP:
await mqttHandlerService.PubComp(context, message as PubCompPacket);
break;
case PacketType.SUBSCRIBE:
await mqttHandlerService.Subscribe(context, message as SubscribePacket);
break;
case PacketType.SUBACK:
await mqttHandlerService.SubAck(context, message as SubAckPacket);
break;
case PacketType.UNSUBSCRIBE:
await mqttHandlerService.Unsubscribe(context, message as UnsubscribePacket);
break;
case PacketType.UNSUBACK:
await mqttHandlerService.UnsubAck(context, message as UnsubAckPacket);
break;
case PacketType.PINGREQ:
await mqttHandlerService.PingReq(context, message as PingReqPacket);
break;
case PacketType.PINGRESP:
await mqttHandlerService.PingResp(context, message as PingRespPacket);
break;
case PacketType.DISCONNECT:
await mqttHandlerService.Disconnect(context, message as DisconnectPacket);
break;
}
}
/// <summary>
/// Unregister an event handler for a packet. This is a low level event
/// interface and should only be used if you are doing something not
/// supported in libsecondlife
/// </summary>
/// <param name="type">Packet type this callback is registered with</param>
/// <param name="callback">Callback to stop firing events for</param>
public void UnregisterCallback(PacketType type, PacketCallback callback)
{
PacketEvents.UnregisterEvent(type, callback);
}
public void Send(uint packetId, DataStream ds, PacketType packetType)
{
Send(packetId, ds.GetBytes(), packetType);
}
private void parseReceivedBuffer(int receivedSize)
{
//////////////////////////////////////////////////////
// ------------------------------------------------ //
// | Paketgröße | Pakettyp | Paket | Dateibytes | //
// ------------------------------------------------ //
// | 4 Bytes | 1 Byte | X Bytes | X Bytes | //
// ------------------------------------------------ //
//////////////////////////////////////////////////////
// Wenn gerade kein Paket gelesen wird
if (this.currentPacketType == PacketType.Invalid)
{
// Wenn die empfangen Bytes nicht ausreichen, um die Paketgröße und den Pakettyp zu lesen
if (receivedSize < sizeof(int) + sizeof(byte))
{
this.receivedBufferOffset = receivedSize;
// Weiter empfangen...
}
// Paketgröße und Pakettyp lesen
else
{
this.currentPacketSize = BitConverter.ToInt32(this.receivedBuffer, this.receivedBufferOffset);
if (Enum.IsDefined(typeof(PacketType), this.receivedBuffer[this.receivedBufferOffset + sizeof(int)]))
{
this.currentPacketType = (PacketType)this.receivedBuffer[this.receivedBufferOffset + sizeof(int)];
int offset = sizeof(int) + sizeof(byte);
// Wenn noch mehr gelesen werden kann
if (receivedSize - offset > 0)
{
this.receivedBufferOffset += offset;
this.parseReceivedBuffer(receivedSize - offset);
}
else
{
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
else
{
this.currentPacketSize = 0;
Console.WriteLine("Empfangener Pakettyp '{0}' ist ungültig!", this.receivedBuffer[this.receivedBufferOffset + sizeof(int)]);
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
}
// Dateipaket lesen
else if (this.currentPacketType == PacketType.File)
{
// Wenn das ganze Paket gelesen werden kann
if (receivedSize >= this.currentPacketSize)
{
// Alle Bytes des Pakets in den Stream schreiben
this.packetStream.Write(this.receivedBuffer, this.receivedBufferOffset, this.currentPacketSize);
// Paket ist fertig!
// Wenn gültiges Paket: Datei empfangen, sonst zurück setzen
try
{
this.currentFilePacket = Newtonsoft.Json.JsonConvert.DeserializeObject <FilePacket>(Encoding.UTF8.GetString(this.packetStream.ToArray()));
this.currentPacketType = PacketType.FileData;
//Console.WriteLine(Encoding.UTF8.GetString(this.packetStream.ToArray()));
//Console.WriteLine("Dateipaket empfangen");
this.ReceiveFileInfo(this.currentFilePacket.Receiver, this.currentFilePacket.Name, this.currentFilePacket.Size);
}
catch
{
this.currentPacketType = PacketType.Invalid;
Console.WriteLine("Dateipaket fehlerhaft!");
}
// Paketstream für nächstes Paket zurücksetzen
this.packetStream.Position = 0;
this.packetStream.SetLength(0);
// Wenn noch mehr Bytes gelesen werden können
if (receivedSize > this.currentPacketSize)
{
this.receivedBufferOffset += this.currentPacketSize;
this.parseReceivedBuffer(receivedSize - this.currentPacketSize);
}
else
{
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
this.currentPacketSize = 0;
}
// Wenn ein Teil des Pakets gelesen werden kann
else
{
// Verfügbare Bytes in den Paketstream schreiben
this.packetStream.Write(this.receivedBuffer, this.receivedBufferOffset, receivedSize);
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
// Datei lesen
else if (this.currentPacketType == PacketType.FileData)
{
// Wenn die Datei noch empfangen wird
if (this.receivedFileSize < this.currentFilePacket.Size)
{
long restSize = this.currentFilePacket.Size - this.receivedFileSize;
// Wenn die fehlenden Bytes vorhanden sind
if (receivedSize >= restSize)
{
byte[] fileBuffer = new byte[restSize];
Array.Copy(this.receivedBuffer, this.receivedBufferOffset, fileBuffer, 0, restSize);
//Console.WriteLine("{0} Bytes der Datei empfangen", restSize);
//Console.WriteLine("Datei komplett empfangen");
// Callback für Dateiverarbeitung
this.receivedFileSize += restSize;
this?.ReceiveFile(this.currentFilePacket.Receiver, fileBuffer, this.receivedFileSize, this.currentFilePacket.Size);
this.currentPacketSize = 0;
this.currentPacketType = PacketType.Invalid;
this.currentFilePacket = null;
this.receivedFileSize = 0;
// Wenn noch mehr Bytes gelesen werden können
if (receivedSize > restSize)
{
this.receivedBufferOffset += (int)restSize;
this.parseReceivedBuffer(receivedSize - (int)restSize);
}
else
{
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
else
{
byte[] fileBuffer = new byte[receivedSize];
Array.Copy(this.receivedBuffer, this.receivedBufferOffset, fileBuffer, 0, receivedSize);
//Console.WriteLine("{0} Bytes der Datei empfangen", receivedSize);
// Callback für Dateiverarbeitung
this?.ReceiveFile(this.currentFilePacket.Receiver, fileBuffer, this.receivedFileSize, this.currentFilePacket.Size);
this.receivedFileSize += receivedSize;
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
else
{
Console.WriteLine("WIE BIN ICH HIER HIN GEKOMMEN???");
System.Diagnostics.Debugger.Break();
}
}
// Objekt lesen
else if (this.currentPacketType == PacketType.Object)
{
// Wenn das ganze Paket gelesen werden kann
if (receivedSize >= this.currentPacketSize)
{
// Alle Bytes des Pakets in den Stream schreiben
this.packetStream.Write(this.receivedBuffer, this.receivedBufferOffset, this.currentPacketSize);
// Paket ist fertig!
//Console.WriteLine("Dateipaket empfangen");
//if (this.name == null)
//{
// try
// {
// var data = (Newtonsoft.Json.Linq.JObject)this.deserialize(this.packetStream.ToArray());
// if (data["$ConnectionInfoName"] != null)
// {
// this.name = (string)data["$ConnectionInfoName"];
// Console.WriteLine("{0} hat sich verbunden", this.name);
// }
// else
// {
// throw new Exception("Es sollte erst ein Name an den Server geschickt werden!");
// }
// }
// catch
// {
// }
//}
//else
{
var data = (JObject)this.deserialize(this.packetStream.ToArray());
foreach (var pair in data)
{
//this.ReceiveObject?.Invoke(pair.Key, JsonConvert.DeserializeObject(pair.Value.ToString()));
if (pair.Key != "Receiver")
{
this.ReceiveObject?.Invoke(data["Receiver"].ToString(), pair.Key, pair.Value.ToString());
}
}
}
// Pakettyp und Paketstream für nächstes Paket zurücksetzen
this.currentPacketType = PacketType.Invalid;
this.packetStream.Position = 0;
this.packetStream.SetLength(0);
// Wenn noch mehr Bytes gelesen werden können
if (receivedSize > this.currentPacketSize)
{
this.receivedBufferOffset += this.currentPacketSize;
this.parseReceivedBuffer(receivedSize - this.currentPacketSize);
}
else
{
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
this.currentPacketSize = 0;
}
// Wenn ein Teil des Pakets gelesen werden kann
else
{
// Verfügbare Bytes in den Paketstream schreiben
this.packetStream.Write(this.receivedBuffer, this.receivedBufferOffset, receivedSize);
this.receivedBufferOffset = 0;
// Weiter empfangen...
}
}
}
public static void serialize(MemoryStream stream, PacketType type)
{
serialize(stream, (UInt32)type);
}
public LinkedSerializerBase(PacketType packetType, ushort blockType)
: base(packetType, blockType)
{
}
public BasePacket Allocate(PacketType type)
{
return(pools[type].GetNew());
}
private static unsafe void myClientInstance_sendPacketEvent(int caveAddress, PacketType packetType, byte[] data)
{
byte *cave = (byte *)caveAddress;
switch (packetType)
{
case PacketType.Client:
lock (mySendClientLock)
{
Packet p;
p.length = data.Length;
p.data = new byte[data.Length];
Buffer.BlockCopy(data, 0, p.data, 0, data.Length);
mySendClientQueue.Enqueue(p);
try
{
while (mySendClientQueue.Count > 0)
{
if ((byte)cave[8] == (byte)0)
{
p = mySendClientQueue.Dequeue();
Marshal.Copy(p.data, 0, myClientSendBuffer, p.length);
cave[0] = myClientBufferAddress[0];
cave[1] = myClientBufferAddress[1];
cave[2] = myClientBufferAddress[2];
cave[3] = myClientBufferAddress[3];
cave[4] = (byte)(p.length & 0xFF);
cave[5] = (byte)((p.length >> 8) & 0xFF);
cave[6] = (byte)((p.length >> 16) & 0xFF);
cave[7] = (byte)((p.length >> 24) & 0xFF);
cave[8] = 0x01;
}
if (mySendClientQueue.Count == 0)
{
break;
}
}
}
catch (Exception)
{
}
}
break;
case PacketType.Server:
//lock (mySendServerLock)
//{
// Packet p;
// p.length = data.Length;
// p.data = new byte[data.Length];
// Buffer.BlockCopy( data, 0, p.data, 0, data.Length );
// mySendServerQueue.Enqueue( p );
// try
// {
// while (mySendServerQueue.Count > 0)
// {
// if ((byte)cave[4] == (byte)0)
// {
// p = mySendServerQueue.Dequeue();
// Marshal.Copy( p.data, 0, myServerSendBuffer, p.length );
// cave[0] = myServerBufferAddress[0];
// cave[1] = myServerBufferAddress[1];
// cave[2] = myServerBufferAddress[2];
// cave[3] = myServerBufferAddress[3];
// cave[4] = 0x01;
// }
// if (mySendServerQueue.Count == 0)
// break;
// }
// }
// catch (Exception e)
// {
// }
//}
lock (mySendServerLock)
{
Marshal.Copy(data, 0, myServerSendBuffer, data.Length);
cave[0] = myServerBufferAddress[0];
cave[1] = myServerBufferAddress[1];
cave[2] = myServerBufferAddress[2];
cave[3] = myServerBufferAddress[3];
cave[4] = 0x01;
while (cave[4] != 0x00)
{
;
}
}
break;
}
}
private async Task <Packet> ProcessPacket(byte[] data)
{
string str = Encoding.UTF8.GetString(data);
if (Regex.IsMatch(str, "^GET"))
{
requestHeader = new RequestHeader(str);
requestHeader.resource = requestHeader.resource.Replace("/csf-websocket-url", "");
Logger.Info($"Requesting resource: {requestHeader.resource}");
string ip1 = tcpclient.Client.RemoteEndPoint.ToString();
string[] ip_parts = ip1.Split(".");
Logger.Info($"IP: {ip1}");
Logger.Debug($"Recieved header: {str}");
if (ip_parts[0] != "172" && ip_parts[0] != "127")
{
ResponseHeader respheader = new ResponseHeader {
responseCode = HttpCodes.OK
};
await Send(respheader);
await Send("Hello World!");
stillOk = false;
}
else if (requestHeader.parameters.ContainsKey("Sec-WebSocket-Key"))
{
ResponseHeader respheader = new ResponseHeader {
responseCode = HttpCodes.SwitchingProtocols
};
respheader.parameters["Server"] = "CSF-Websocket";
respheader.parameters["Connection"] = "Upgrade";
respheader.parameters["Upgrade"] = "websocket";
respheader.parameters["Sec-WebSocket-Accept"] = GenerateSecWebSocketKey(requestHeader.parameters["Sec-WebSocket-Key"]);
try {
if (requestHeader.parameters.ContainsKey("Sec-WebSocket-Extensions"))
{
Logger.Info($"Supported extensions: {requestHeader.parameters["Sec-WebSocket-Extensions"]}");
Chiper = StreamCipher.Factory(requestHeader.parameters["Sec-WebSocket-Extensions"]);
}
else
{
Chiper = StreamCipher.Factory("permessage-deflate");
}
if (requestHeader.parameters.ContainsKey("Sec-WebSocket-Protocol"))
{
string[] options = requestHeader.parameters["Sec-WebSocket-Protocol"].Split(",");
foreach (string option_raw in options)
{
string option = option_raw.Trim();
if (option.Contains("csf-socket-"))
{
respheader.parameters["Sec-WebSocket-Protocol"] = option;
}
}
}
await Send(respheader);
await SendHello();
} catch (UnsupportedExtension) {
ResponseHeader invext = new ResponseHeader {
responseCode = HttpCodes.NotAcceptable
};
await Send(invext);
await Send("The requested websokcet extension is not supported");
stillOk = false;
}
}
else
{
ResponseHeader respheader = new ResponseHeader {
responseCode = HttpCodes.UpgradeRequired
};
await Send(respheader);
await Send("This is not a website! Upgrade your connection to WebSocket");
stillOk = false;
}
}
else
{
WsPacket WebSocketPacket = Chiper.Decode(data);
OpCode opcode = WebSocketPacket.GetOpCode();
if (opcode == OpCode.TextFrame)
{
string pstr = WebSocketPacket.GetPayload();
try {
Packet p = new Packet(pstr);
PacketType type = p.GetPacketType();
if (type == PacketType.Heartbeat)
{
HeartBeatNow();
Packet ack = new Packet(PacketType.HeartbeatACK);
await Send(ack);
return(null);
}
else if (type == PacketType.Reconnect)
{
Reconnect rp = p.GetPacketData <Reconnect>();
if (UsedSessions.Contains(rp.session_id))
{
this.session = rp.session_id;
await SendHello();
}
else
{
Packet invsess = new Packet(PacketType.InvalidSession);
await Send(invsess);
stillOk = false;
}
return(null);
}
else if (type == PacketType.Identify)
{
identity = p.GetPacketData <Identity>();
}
else
{
if (identity == null)
{
stillOk = false;
return(null);
}
}
return(p);
} catch (Exception e) {
Logger.Error($"Packet conversion error: {e.Message}");
Logger.Error($"Receied data: {string.Join(" ", data)}");
Logger.Error($"Decoded: {pstr}");
Logger.Error($"{e.StackTrace}");
}
}
else if (opcode == OpCode.Ping)
{
Logger.Debug("Ping Pong");
WsPacket pong = new WsPacket(OpCode.Pong);
await Send(pong);
}
}
return(null);
}
public static void Register(PacketType packetID, int length, int minimumLength, OnPacketReceive onReceive)
{
_handlers[(byte)packetID] = new ClientPacketHandler(packetID, length, minimumLength, onReceive);
}
public static void SendAll(PacketType packetType, INetSerializable packet)
{
var netDataWriter = CSEngineApp.App.LiteNet.WriteSerializable(packetType, packet);
CSEngineApp.App.LiteNet._netManager.SendToAll(netDataWriter, DeliveryMethod.Unreliable);
}
public override void DoActions(ref Client client)
{
var clientManager = ClientManager.GetInstance();
var roomManager = RoomManager.GetInstance();
Friend friend;
switch (PacketType)
{
case PacketType.c_LogIn:
friend = Data as Friend;
if (null != friend)
{
ProcessLogInPacket(client, friend);
}
break;
case PacketType.c_LogOut:
clientManager.RemoveClient(client);
break;
case PacketType.c_JoinRoom:
friend = Data as Friend;
if (null != friend)
{
client = ProcessJoinRoomPacket(client, friend);
}
break;
case PacketType.c_LeaveRoom:
roomManager.RemoveMemberfromRoom(client.Room.Host, client);
//
// Add the user to a newly createad room.
//
var newRoom = roomManager.CreateNewRoom(client);
client.Room = newRoom;
break;
case PacketType.c_InitiateGame:
//
// Only allow the room host to initiate a game.
//
if (client.Room.GetHostAddress() == client.UserInfo.EmailAddress)
{
MessageSender.BroadcastMessage(
client.Room.Members,
PacketType.s_BeginGameInitialization,
null,
client);
}
break;
case PacketType.c_Chat:
var arguments = Data as ChatMessage;
if (arguments != null)
{
MessageSender.BroadcastMessage(client.Room.Members, PacketType.s_Chat, arguments, client);
}
break;
case PacketType.c_ReadyForGameStart:
client.Room.SignalClientIsReadyForGame(client);
break;
default:
Trace.WriteLine(string.Format("[RoomPacketHandler.DoActions] - " +
"Invalid packet type for this PacketHandler = {0}", PacketType.ToString()));
break;
}
}
public static ClientPacketHandler GetHandler(PacketType packetID)
{
return(_handlers[(byte)packetID]);
}
