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]); }