HEGII.ft.mes.plc/HslCommunication_Net35/Enthernet/SimplifyNet/NetSimplifyServer.cs

using HslCommunication.Core.Net;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;

namespace HslCommunication.Enthernet
{
    /// <summary>
    /// IP防护类型
    /// </summary>
    public enum IPShieldType
    {
        /// <summary>
        /// 不防护，全部允许
        /// </summary>
        None = 0,
        /// <summary>
        /// 白名单
        /// </summary>
        WhiteList,
        /// <summary>
        /// 黑名单
        /// </summary>
        BlackList
    }

    /// <summary>
    /// 同步消息处理服务器，主要用来实现接收客户端信息并进行消息反馈的操作
    /// </summary>
    public class NetSimplifyServer : NetworkServerBase
    {
        #region 客户端连接防护
        /// <summary>
        /// 客户端连接防护类型
        /// </summary>
        public IPShieldType ClientIPShieldType
        {
            get;
            set;
        } = IPShieldType.None;
        /// <summary>
        /// 白名单
        /// </summary>
        public List<string> WhiteList
        {
            get;
            set;
        }
        /// <summary>
        /// 黑名单
        /// </summary>
        public List<string> BlackList
        {
            get;
            set;
        }
        #endregion

        #region Constructor

        /// <summary>
        /// 实例化一个服务器消息请求的信息
        /// </summary>
        public NetSimplifyServer()
        {
            // cxy
            HslProtocol.HeadByteLength = 8;
        }

        #endregion
        
        #region 事件通知块

        /// <summary>
        /// 接收字符串信息的事件
        /// </summary>
        public event Action<AppSession, NetHandle, string> ReceiveStringEvent;
        /// <summary>
        /// 接收字节信息的事件
        /// </summary>
        public event Action<AppSession, NetHandle, byte[]> ReceivedBytesEvent;


        private void OnReceiveStringEvent( AppSession session, int customer, string str )
        {
            ReceiveStringEvent?.Invoke( session, customer, str );
        }

        private void OnReceivedBytesEvent( AppSession session, int customer, byte[] temp )
        {
            ReceivedBytesEvent?.Invoke( session, customer, temp );
        }

        #endregion

        #region 启动停止块

        /// <summary>
        /// 关闭网络的操作
        /// </summary>
        protected override void CloseAction()
        {
            ReceivedBytesEvent = null;
            ReceiveStringEvent = null;
            base.CloseAction( );
        }

        // cxy
        public void SendMessage(AppSession session, string customer)
        {
            SendBytesAsync(session, Encoding.ASCII.GetBytes(customer));
        }

        /// <summary>
        /// 向指定的通信对象发送字符串数据
        /// </summary>
        /// <param name="session">通信对象</param>
        /// <param name="customer">用户的指令头</param>
        /// <param name="str">实际发送的字符串数据</param>
        public void SendMessage( AppSession session, int customer, string str )
        {
            SendBytesAsync( session, HslProtocol.CommandBytes( customer, Token, str ) );
        }
        /// <summary>
        /// 向指定的通信对象发送字节数据
        /// </summary>
        /// <param name="session">连接对象</param>
        /// <param name="customer">用户的指令头</param>
        /// <param name="bytes">实际的数据</param>
        public void SendMessage( AppSession session, int customer, byte[] bytes )
        {
            SendBytesAsync( session, HslProtocol.CommandBytes( customer, Token, bytes ) );
        }

        /// <summary>
        /// 处理请求接收连接后的方法
        /// </summary>
        /// <param name="obj"></param>
        protected override void ThreadPoolLogin( object obj )
        {
            if (obj is Socket)
            {
                Socket socket = obj as Socket;
                AppSession session = new AppSession( );
                session.WorkSocket = socket;
                try
                {
                    session.IpEndPoint = (System.Net.IPEndPoint)socket.RemoteEndPoint;
                    session.IpAddress = session.IpEndPoint.Address.ToString( );

                    // IP防护过滤 by cxy 2021-07-26
                    if (this.ClientIPShieldType == IPShieldType.WhiteList)
                    {
                        if (!(this.WhiteList?.Contains(session.IpAddress) ?? false))
                        {
                            LogNet?.WriteDebug(ToString(), $"客户端 [ {session.IpEndPoint} ] 不在白名单中");
                            // 应该关闭网络通信
                            LogNet?.WriteWarn(ToString(), $"客户端 [ {session.IpEndPoint} ] 不在白名单中");
                            AppSessionRemoteClose(session);
                            return;
                        }
                    }
                    else if (this.ClientIPShieldType == IPShieldType.BlackList)
                    {
                        if ((this.BlackList?.Contains(session.IpAddress) ?? false))
                        {
                            LogNet?.WriteDebug(ToString(), $"客户端 [ {session.IpEndPoint} ] 在黑名单中");
                            // 应该关闭网络通信
                            LogNet?.WriteWarn(ToString(), $"客户端 [ {session.IpEndPoint} ] 在黑名单中");
                            AppSessionRemoteClose(session);
                            return;
                        }
                    }
                }
                catch(Exception ex)
                {
                    LogNet?.WriteException( ToString( ), "Ip信息获取失败", ex );
                }

                LogNet?.WriteDebug( ToString( ), $"客户端 [ {session.IpEndPoint} ] 上线" );
                ReBeginReceiveHead( session, false );
            }
        }

        /// <summary>
        /// 处理异常的方法
        /// </summary>
        /// <param name="session"></param>
        /// <param name="ex">异常信息</param>
        internal override void SocketReceiveException( AppSession session, Exception ex )
        {
            session.WorkSocket?.Close( );
            LogNet?.WriteDebug( ToString( ), $"客户端 [ {session.IpEndPoint} ] 异常下线" );
        }

        /// <summary>
        /// 正常下线
        /// </summary>
        /// <param name="session"></param>
        internal override void AppSessionRemoteClose( AppSession session )
        {
            session.WorkSocket?.Close( );
            LogNet?.WriteDebug( ToString( ), $"客户端 [ {session.IpEndPoint} ] 下线" );
        }

        /// <summary>
        /// 数据处理中心
        /// </summary>
        /// <param name="session">当前的会话</param>
        /// <param name="protocol">协议指令头</param>
        /// <param name="customer">客户端信号</param>
        /// <param name="content">触发的消息内容</param>
        internal override void DataProcessingCenter( AppSession session, int protocol, int customer, byte[] content )
        {
            //接收数据完成，进行事件通知，优先进行解密操作
            if (protocol == HslProtocol.ProtocolCheckSecends)
            {
                // 初始化时候的测试消息
                session.HeartTime = DateTime.Now;
                SendMessage( session, customer, content );
            }
            else if (protocol == HslProtocol.ProtocolUserBytes)
            {
                // 字节数据
                OnReceivedBytesEvent( session, customer, content );
            }
            else if (protocol == HslProtocol.ProtocolUserString)
            {
                // 字符串数据
                OnReceiveStringEvent( session, customer, Encoding.Unicode.GetString( content ) );
            }
            else
            {
                // 数据异常
                session?.WorkSocket?.Close( );
            }
        }

        #endregion

        #region Object Override

        /// <summary>
        /// 获取本对象的字符串表示形式
        /// </summary>
        /// <returns></returns>
        public override string ToString( )
        {
            return "NetSimplifyServer";
        }


        #endregion

        protected override int GetReceiveLength(AppSession session)
        {
            return Convert.ToInt32(Encoding.ASCII.GetString(session.BytesHead, 4, 4), 16);
        }

        protected override int GetCustomer(byte[] head)
        {
            return Convert.ToInt32(Encoding.ASCII.GetString(head, 0, 4), 16);
        }
    }
}