示例#1
0
        public void Send(Packet outPacket)
        {
            lock (this)
            {
                if (IsAlive)
                {
                    short  packetOPCODE    = outPacket.OperationCode;
                    string packetName      = Enum.GetName(typeof(TSendOP), packetOPCODE);
                    byte[] packetByteArray = outPacket.Array;
                    string currentTime     = DateTime.Now.ToString("HH:mm:ss");

                    // add new packet event to log que
                    LogEventQue.LogEvent newLogEvent = new LogEventQue.LogEvent
                    {
                        EventTime = currentTime,
                        EventName = packetName,
                        EventData = packetByteArray
                    };

                    outPacket.SafeFlip();
                    Socket.Send(Cryptograph.Encrypt(outPacket.GetContent()));

                    if (Enum.IsDefined(typeof(TSendOP), outPacket.OperationCode))
                    {
                        if (LogEventQue.NormalEventsLog.Count > 499)
                        {
                            LogEventQue.LogEvent lastLogEvent = LogEventQue.NormalEventsLog.FirstOrDefault();

                            LogEventQue.NormalEventsLog.Remove(lastLogEvent);
                            LogEventQue.NormalEventsLog.Add(newLogEvent);
                        }

                        LogEventQue.NormalEventsLog.Add(newLogEvent);

                        switch (Packet.LogLevel)
                        {
                        case LogLevel.Name:
                            Log.Inform("[{0}][ClientHandler]: \n Sent [{1}] packet to [{2}].", newLogEvent.EventTime, newLogEvent.EventName, Title);
                            break;

                        case LogLevel.Full:
                            Log.Hex("Sent {0} packet to {1}: ", outPacket.GetContent(), Enum.GetName(typeof(TSendOP), outPacket.OperationCode), Title);
                            break;

                        case LogLevel.None:
                            break;

                        default:
                            throw new ArgumentOutOfRangeException();
                        }
                    }
                    else
                    {
                        Log.SkipLine();
                        Log.Hex("Sent unknown (0x{0:X2}) packet to {1}: ", outPacket.Array, outPacket.OperationCode, Title);
                        Log.SkipLine();

                        LogEventQue.AnomalousEventsLog.Add(newLogEvent);
                    }
                }
                else
                {
                    //Log.Warn("Tried to send {0} packet to dead client.", Enum.GetName(typeof(TSendOP), Packet.OperationCode));
                }
            }
        }
示例#2
0
        private void HandleIncomingPacket(byte[] rawPacket)
        {
            using (Packet inPacket = new Packet(Cryptograph.Decrypt(rawPacket)))
            {
                // parse information from packet
                short  packetOPCODE    = inPacket.OperationCode;
                string packetName      = Enum.GetName(typeof(TReceiveOP), packetOPCODE);
                byte[] packetByteArray = inPacket.Array;
                string currentTime     = DateTime.Now.ToString("HH:mm:ss");

                // create new log event out of inPacket information
                LogEventQue.LogEvent newLogEvent = new LogEventQue.LogEvent
                {
                    EventTime = currentTime,
                    EventName = packetName,
                    EventData = packetByteArray
                };

                // check if packet operation code is known
                if (Enum.IsDefined(typeof(TReceiveOP), packetOPCODE))
                {
                    if (LogEventQue.NormalEventsLog.Count > 499)
                    {
                        LogEventQue.LogEvent lastLogEvent = LogEventQue.NormalEventsLog.FirstOrDefault();

                        LogEventQue.NormalEventsLog.Remove(lastLogEvent);
                        LogEventQue.NormalEventsLog.Add(newLogEvent);
                    }

                    LogEventQue.NormalEventsLog.Add(newLogEvent);

                    switch (Packet.LogLevel)
                    {
                    case LogLevel.Name:
                        Log.Inform("[{0}][ClientHandler]: \n Received [{1}] packet from [{2}].", newLogEvent.EventTime, newLogEvent.EventName, Title);
                        break;

                    case LogLevel.Full:
                        Log.Hex("[{0}] Received [{1}] packet from [{2}]: ", newLogEvent.EventData, newLogEvent.EventTime, newLogEvent.EventName, Title);
                        break;

                    case LogLevel.None:
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                }

                // else log as anomalous event
                else
                {
                    Log.SkipLine();
                    Log.Hex("Received unknown (0x{0:X2}) packet from {1}: ", packetByteArray, packetOPCODE, Title);
                    Log.SkipLine();

                    LogEventQue.AnomalousEventsLog.Add(newLogEvent);
                }

                // dispatch regardless if we know the packet
                Dispatch(inPacket);
            }
        }