public void addServer(TcpServer tcps)
{
//...lägg till servern i en lista...
this.tcps = tcps;
Thread t = new Thread(tcps.thread);
t.Start();
}
public TcpTestServer()
{
_testport = TestPort.Create();
_testserver = new TcpServer(IPAddress.Loopback.ToString(), _testport);
_testserver.Connected += Connected;
_testserver.Start();
}
/// <summary></summary>
public void EnsureServer()
{
if (Server == null)
{
if (ProtocolType == NetType.Tcp)
{
var server = new TcpServer();
Server = server;
//server.ReuseAddress = true;
server.NewSession += server_Accepted;
}
else
{
var server = new UdpServer();
//Server = server;
//server.ReuseAddress = true;
server.Received += server_Received;
//server.Bind();
server.ReceiveAsync();
}
Server.Start();
WriteLog("监听：{0}", Server);
}
}
public NanoHttpServer(int port)
{
_handlers = new Dictionary<string, IRequestHandler>();
_tcp = new TcpServer(port);
_tcp.ConnectionAdded += OnConnectionAdded;
_root = new StubHandler("Page not ready yet".ToNoStyleHtmlBody());
}
public void RegisterHandlersTo(TcpServer server)
{
if (server == null)
return;
server.Register(HandleLoginRequest);
}
//private DbItem GetUserItem(TcpConnectedHost host)
//{
// return _authenticationProviders.Where(p => p.IsAuthenticated(host)).Select(p => p.GetUserItem(host)).FirstOrDefault();
//}
public void RegisterTo(TcpServer server)
{
_dataService.ItemChanged += delegate(int id)
{
var message = new ObjectTcpMessage<ItemChangeEvent>(TcpRequestType.List);
message.Add(new ItemChangeEvent { Id = id });
server.Enqueue(message);
};
_dataService.RelationAdded += delegate(DbRelation relation)
{
var message = new ObjectTcpMessage<DbRelation>(TcpRequestType.InsertRelation);
message.Add(relation);
server.Enqueue(message);
};
_dataService.RelationRemoved += delegate(DbRelation relation)
{
var message = new ObjectTcpMessage<DbRelation>(TcpRequestType.DeleteRelation);
message.Add(relation);
server.Enqueue(message);
};
server.Register(HandleMultiRelationQuery);
server.Register(HandleUniqueRelationQuery);
server.Register(HandleInsertRelation);
server.Register(HandleDeleteRelation);
server.Register(HandleUniqueItemQuery);
server.Register(HandleInsertItem);
server.Register(HandleUpdateItem);
server.Register(HandleDeleteItem);
}
public TcpDataServiceServer(DataServiceBase dataService, TcpServer server)
: this(dataService)
{
if (server == null)
server = new TcpServer();
RegisterTo(server);
}
static void Main(string[] args)
{
bool error = false;
if (args.Length != 2) {
Console.WriteLine("Syntax: program.exe <port> <baudrate>");
Console.WriteLine("port - can be in form of /dev/ttyS0 or com2 or /udp/ipaddress/port");
Console.WriteLine("baudrate - any baudrate like 19200 (for udp baudrate could be any number)");
Console.WriteLine("");
Console.WriteLine("example: program.exe /dev/ttyUSB0 19200");
Console.WriteLine("example: program.exe /udp/192.168.0.10/1100 0");
error = true;
return;
}
if (!error) {
//Console.WriteLine("arg0: " + args[0] + "\n");
argPort = args[0];
argBaud = Int32.Parse(args[1]);
}
if (!error) {
if (DEBUG_LEVEL>0) {
Console.WriteLine("canDaemon");
Console.WriteLine("Commands:");
//Console.WriteLine("reset - reset communication.");
Console.WriteLine("exit - exit program");
Console.WriteLine("");
Thread.Sleep(1000);
}
sc = new SerialConnection();
try {
sc.setConfiguration(argBaud, System.IO.Ports.Parity.None, argPort, System.IO.Ports.StopBits.One, 8, false);
}
catch (Exception e) { Console.WriteLine("Error: " + e.Message); }
if (!sc.open()) {
Console.WriteLine("Error opening port to target");
//... här ska man testa om igen...
} else {
d = new Daemon(sc);
tcps = new TcpServer(1200);
d.addServer(tcps);
Thread t = new Thread(d.thread);
t.Start();
string instr;
do {
//Console.Write("> ");
instr = Console.ReadLine().ToLower();
} while (parseInput(instr));
d.stop();
}
}
}
static void Main(string[] args)
{
_helloServer = new TcpServer<HelloClient>(IPAddress.Any, 8000);
_helloServer.Start();
Console.WriteLine("Serveur démarré\nAppuyez sur une touche pour terminer");
Console.ReadLine();
_helloServer.Stop();
}
static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure();
server = new TcpServer(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 15672));
server.Start();
subscriber = new TcpServerSubscriber();
server.Subscribe(subscriber);
ReadLine();
new ManualResetEvent(false).WaitOne(Timeout.Infinite);
}
public TcpServerSocket(TcpServer server)
: base(server.Loop)
{
if (server == null)
throw new ArgumentNullException("server");
_server = server;
this.Accept();
this.Status = HandleStatus.Open;
}
public static void Main(string[] args)
{
ServerConfiguration config = new ServerConfiguration ();
config.Port = 3000;
config.IP = IPAddress.Any;
//config.IP = IPAddress.Parse("127.0.0.1");
TcpServer server = new TcpServer (config);
TcpManager manager = new TcpManager (server);
ServerLogic logic = new ServerLogic (manager);
logic.StartServer ();
}
public void ServerStartsAndStopsWithCorrectInfoWait()
{
using (var server = new TcpServer(Port, 1, Name, Version))
{
Assert.AreEqual(server.Name, Name);
Assert.AreEqual(server.Version, Version);
Assert.AreEqual(0, server.Clients.Count);
Assert.AreEqual(ServerState.Stopped, server.State);
server.Start(true);
Assert.AreEqual(ServerState.Running, server.State);
Assert.AreEqual(0, server.Clients.Count);
server.Stop(true);
Assert.AreEqual(ServerState.Stopped, server.State);
}
}
static void Main(string[] args)
{
Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
DataServiceBase service = new TcpDataService(new TcpClient("home.sorenhk.dk"));
service = new CacheDataService(service);
var tcpServer = new TcpServer();
var server = new TcpDataServiceServer(service);
server.RegisterTo(tcpServer);
Console.ReadLine();
tcpServer.Dispose();
service.Dispose();
}
void Connected(object sender, TcpServer.ConnectedEventArgs e)
{
try
{
System.Security.Cryptography.MD5 MD5 = System.Security.Cryptography.MD5.Create();
using (ReaderWriter io = new ReaderWriter(e.Stream))
{
while (true)
{
byte[] bytes = io.Read();
if (bytes.Length == 0)
break;
io.Write(MD5.ComputeHash(bytes));
}
}
}
finally { e.Close(); }
}
public void ClientConnectsAndDisconnectsWait()
{
using (var server = new TcpServer(Port, 1, Name, Version))
using (var client = new TcpClient(new IPEndPoint(IPAddress.Loopback, Port), Version))
{
server.Start();
client.Open(true);
Assert.AreEqual(ClientStatus.Ok, client.Status);
Assert.AreEqual(1, server.Clients.Count);
Assert.AreEqual(ClientStatus.Ok, server.Clients[0].Status);
Assert.AreEqual(IPAddress.Loopback, server.Clients[0].RemoteEndpoint.Address);
Assert.AreEqual(client.RemoteEndpoint, server.Clients[0].LocalEndpoint);
Assert.AreEqual(client.LocalEndpoint, server.Clients[0].RemoteEndpoint);
client.Close(true);
Assert.AreEqual(ClientStatus.Closed, client.Status);
}
}
/// <summary>
/// Handles the OnStart event of the Application control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
public void Application_OnStart(object sender, EventArgs e)
{
loggerFactory = new Log4NetLoggerFactory();
logger = loggerFactory.CreateLogger<DefaultHttpApplication>("Framework");
logger.Info("***********************应用程序服务器准备启动************************");
DefaultContainer.LoggerFactory = loggerFactory;
try
{
StartHost();
int port = Convert.ToInt32(ConfigurationManager.AppSettings["ServerSocketPort"]);
int capacity = Convert.ToInt32(ConfigurationManager.AppSettings["Capactity"]);
tcpServer = new TcpServer(port, capacity, logger);
tcpServer.Start();
logger.Info("TCP 服务在端口 [" + port + "] 开始监听");
}
catch (Exception ex)
{
logger.Error("TCP 服务启动失败", ex);
}
}
public static void Main()
{
Utils.Log_Init();
int port = 12345;
bool bUseIPv6 = false;
var Server = new TcpServer(port, bUseIPv6);
//Server.Start(TransparentProxy.CreateProxy);
Server.Start(RedirectingProxy.CreateProxy);
Server.InitListenFinished.WaitOne();
if (Server.InitListenException != null)
throw Server.InitListenException;
while (true)
System.Threading.Thread.Sleep(1000);
//Server.Stop();
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultApplication"/> class.
/// </summary>
public DefaultApplication()
{
loggerFactory = new Log4NetLoggerFactory();
logger = loggerFactory.CreateLogger<DefaultHttpApplication>("Framework");
logger.Info("***********************应用程序服务器准备启动************************");
DefaultContainer.LoggerFactory = loggerFactory;
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
try
{
int port = Convert.ToInt32(ConfigurationManager.AppSettings["ServerSocketPort"]);
int capacity = Convert.ToInt32(ConfigurationManager.AppSettings["Capacity"]);
tcpServer = new TcpServer(port, 100, logger);
tcpServer.Start();
logger.Info("TCP 服务在端口 [" + port + "] 开始监听");
}
catch (Exception ex)
{
logger.Error("TCP 服务启动失败", ex);
}
}
public void Start(int port)
{
if (_server == null)
{
_server = new TcpServer {
Log = ServiceLogger.Current.Logger, Port = port, MaxNotActive = 120
};
_server.NewSession += server_NewSession;
}
try
{
_server.Start();
if (_timer == null)
{
_timer = new TimerX(ShowSessions, _server, 1000, 1000);
}
NetHelper.ShowTcpParameters();
EnableProcessMessage = true;
//ProcessMessage();
const int threadCount = 2;
processThreads = new Thread[threadCount];
for (int i = 0; i < threadCount; i++)
{
//Task.Factory.StartNew(ProcessMessage);
Thread th = new Thread(ProcessMessage);
th.IsBackground = true;
th.Name = "解析数据线程" + i.ToString();
th.Priority = ThreadPriority.AboveNormal;
th.Start();
processThreads[i] = th;
Thread.Sleep(5000);
}
}
catch (Exception ex) { ServiceLogger.Current.WriteException(ex); }
}
public void ServertCertCheckTest()
{
var serverName = "TestServer";
using (X509Certificate serverCert = MakeCert(serverName))
{
var server = new TcpServer();
var epList = new List <TcpServerLocalEndpoint>();
var ipEp1 = (new TcpServerLocalEndpoint(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1234), 1));
epList.Add(ipEp1);
server.Start(epList, serverCert, true, SslProtocols.None, false, EncryptionPolicy.RequireEncryption);
X509Certificate clientCert = MakeCert(serverName);
var client = new EncryptedTcpClientTestClass();
client.ServerCertificate = null;
client.Start(ipEp1.EndPoint, serverName, clientCert, SslProtocols.None, false, EncryptionPolicy.RequireEncryption);
var waitStart = DateTime.Now;
while (client.ServerCertificate == null)
{
var delta = DateTime.Now - waitStart;
if (delta.TotalSeconds > 5)
{
Assert.Fail("Wait Timeout");
}
}
Assert.IsNotNull(client.ServerCertificate);
Assert.AreEqual(serverCert, client.ServerCertificate);
client.Stop();
server.Stop();
server.Dispose();
client.Dispose();
clientCert.Dispose();
}
}
private void OnReceiver(Object _object, TcpReceiverEventArgs _tcpEventArgs)
{
String Client = TcpServer.GetHostName(_tcpEventArgs.Socket);
String Message = Encoding.UTF8.GetString(_tcpEventArgs.Buffer, 0, _tcpEventArgs.Length);
if (Message != "")
{
if (Message.IsConnect())
{
if (_clients.IndexOf(Client) == -1)
{
_clients.Add(Client);
}
}
if (_clients.Count > 0)
{
List <String> _temp = new List <String>();
foreach (String _client in _clients)
{
try
{
Byte[] Request = Encoding.UTF8.GetBytes(TcpRequest.Connect);
Program.Server.Send(_client, Program.Config.Port, Request);
}
catch { _temp.Add(_client); }
}
foreach (String _client in _temp)
{
_clients.Remove(_client);
}
}
BeginInvoke(
new MethodInvoker(delegate { label1.Text = _clients.Count.ToString(); }));
}
}
private async void HandleClientActivityCheckAsync()
{
_logger.UpdateLog("Client activity check handling started!");
List <PlayerDetails> playerDetailsList = null;
ClientHandlerInfo clientHandlerInfo = null;
int tcpClientId = -1;
while (this.State == WorkingState.Enabled)
{
await Task.Factory.StartNew(() => Thread.Sleep(_activityCheckTickRate));
playerDetailsList = _playerHandler.GetAllPlayers();
if (playerDetailsList == null)
{
continue;
}
foreach (PlayerDetails details in playerDetailsList)
{
tcpClientId = details.TcpClientId;
clientHandlerInfo = TcpServer.GetClientInfo(tcpClientId);
if (clientHandlerInfo == null)
{
continue;
}
if (!clientHandlerInfo.IsWorking)
{
_logger.UpdateLog($"Activity check - unregistering player with TCP client ID [{tcpClientId}]...");
_playerHandler.UnregisterPlayer(tcpClientId);
}
}
playerDetailsList.Clear();
playerDetailsList = null;
clientHandlerInfo = null;
}
}
public HubbleTask(string path, bool startFromService)
{
_StartTime = DateTime.Now;
path = path.Replace("\"", "");
if (startFromService)
{
string intanceName = TaskInformation.GetCurrentIntanceName(path);
TaskInformation.SetStartTime(intanceName, _StartTime);
}
Init(path);
_Server = new TcpServer(Global.Setting.Config.TcpPort);
if (startFromService)
{
string intanceName = TaskInformation.GetCurrentIntanceName(path);
if (Global.Setting.Config.TcpPort != TaskInformation.GetTcpPort(intanceName))
{
TaskInformation.SetTcpPort(intanceName, Global.Setting.Config.TcpPort);
}
}
_Server.MaxConnectNum = Global.Setting.Config.MaxConnectNum;
_Server.ConnectEstablishEventHandler += ConnectEstablishEventHandler;
_Server.DisconnectEventHandler += DisconnectEventHandler;
_Server.MessageReceiveEventHandler += MessageReceiveEventHandler;
_Server.MessageReceiveErrorEventHandler += MessageReceiveErrorEventHandler;
_Server.LocalAddress = null;
_Server.RequireCustomSerialization = RequireCustomSerialization;
_Server.Listen();
Global.Report.WriteAppLog("Hubble.net start successful", true);
}
public GameServer()
{
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
Log.Info("Initializing SabberStone GameServer!");
_gameServer = new TcpServer(2010, "127.0.0.1");
_gameServer.OnConnected += OnConnected;
_gameServer.OnDisconnected += OnDisconnected;
_gameServer.OnReceived += OnReceived;
_gameServer.OnException += OnException;
_gameServer.OnStarted += OnStarted;
_gameServer.OnStopped += OnStopped;
_id = 1; // server id
_token = "server"; // server token
_registredUsers = new ConcurrentDictionary <string, UserInfoData>();
_matchMaker = new MatchMaker(this);
}
public void ClientConnectDisconnect_Event()
{
TcpServer server = new TcpServer("TestServer-Event");
server.Start(12200);
try
{
Client1 = new TcpClient("127.0.0.1", 12200);
Client1.ConnectionStatusChanged += Client_ConnectionStatusChanged;
Client1.Connect();
Thread.Sleep(200);
Assert.AreEqual(true, ClientConnectFlag);
server.Stop();
Thread.Sleep(200);
Assert.AreEqual(false, ClientConnectFlag);
}
finally
{
Client1.Disconnect();
server.Dispose();
}
}
public void Start()
{
// Unity coordinate frame.
_info.CoordinateFrame = Tes.Net.CoordinateFrame.XZY;
_packet = new PacketBuffer(1024);
if (Instance == null)
{
Instance = this;
foreach (TesPhysicsView view in Resources.FindObjectsOfTypeAll(typeof(TesPhysicsView)))
{
Add(view);
}
}
StopServer();
// Manual cache management transmit on new connection.
Settings.Flags &= ~ServerFlag.Collate; // Not working
_server = new TcpServer(Settings, _info);
_server.ConnectionMonitor.Start(ConnectionMonitorMode.Asynchronous);
}
public void StatefulTcpTest()
{
Server server = new TcpServer(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8055));
server.RegisterStatefulService <IService>(typeof(Calculator));
server.Start();
Client client = new TcpClient(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8055));
client.Connect();
IService service = client.GetServiceProxy <IService>();
service.Sum(9, 11);
service.Sum(2, 4);
int result = service.GetNumberOfCalls();
client.Disconnect();
server.Stop();
Assert.Equal(2, result);
}
/// <inheritdoc/>
protected override void OnClosing(CancelEventArgs e)
{
base.OnClosing(e);
if (CaptureDevice != null)
{
CaptureDevice.Dispose();
CaptureDevice = null;
}
if (TcpServer != null)
{
HPSocketExtension.DisposeServer(TcpServer);
TcpServer = null;
}
if (UdpServer != null)
{
HPSocketExtension.DisposeServer(UdpServer);
UdpServer = null;
}
Log.InfoFormat("Window Closing");
}
public void ClientConnectEventsTest()
{
using (TcpServer server = new TcpServer())
{
int Port = 10000;
SubscribeEvent(server);
server.Start(Port);
server.ClientConnecting += (sender, e) => { ClientConnectingEvent = true; Trace.WriteLine("Client Connecting"); };
server.ClientConnected += (sender, e) => { ClientConnectedEvent = true; Trace.WriteLine("Client Connected"); };
ClientConnectingEvent = false;
ClientConnectedEvent = false;
TcpClient client = new TcpClient("127.0.0.1", Port);
client.Connect();
Assert.AreEqual(true, client.Connected);
Trace.WriteLine("Client Connected to Server.");
TcpDelay();
Assert.AreEqual(true, ClientConnectingEvent);
Assert.AreEqual(true, ClientConnectedEvent);
Assert.AreEqual(1, server.Clients.Count);
Trace.WriteLine("Test End");
}
}
static void Main()
{
IPEndPoint endpoint = new IPEndPoint(IPAddress.Loopback, 6002);
using (var server = new TcpServer())
{
server.ProtocolFactory = WebSocketsSelectorProcessor.Default;
server.ConnectionTimeoutSeconds = 60;
server.Received += msg =>
{
var conn = (WebSocketConnection)msg.Connection;
string reply = (string)msg.Value + " / " + conn.Host;
Console.WriteLine("[server] {0}", msg.Value);
msg.Connection.Send(msg.Context, reply);
};
server.Start("abc", endpoint);
Console.WriteLine("Server running");
Console.ReadKey();
}
Console.WriteLine("Server dead; press any key");
Console.ReadKey();
}
private ChannelController()
{
server = new TcpServer()
{
AcceptBacklog = 1, AcceptThreads = 1
};
server.ClientAccepted += server_ClientAccepted;
server.ClientException += server_ClientException;
server.Listen(Config.ChannelServerPort);
Ip = "-";
Status = DeviceState.初始化.ToString();
NLog.LogManager.GetCurrentClassLogger().Info("Sever Start At " + Config.ChannelServerPort.ToString());
orderOkQueue = new OrderMessageInputQueue(EnumChannel.正常道口);
orderErrQueue = new OrderMessageInputQueue(EnumChannel.异常道口);
boxQueue = new BoxInChannelInputQueue();
orderArrivedOkQueue = new OrderMessageArrivedInputQueue();
CountOkArrived = new ChannelCount();
CountOkTake = new ChannelCount();
CountErr = new ChannelCount();
}
/// <summary>
/// Запустить Tcp сервер
/// </summary>
public void Start()
{
server = new TcpServer(m_numConnections, m_receiveBuferSize);
server.OnConnect += new ServerEventHandler(OnConnect);
server.OnDisconnect += new ServerEventHandler(OnDisconnect);
server.OnReceive += new ServerReceiveEventHandler(OnReceive);
server.Port = Port;
server.Start();
/*server = new Server();
*
* server.Port = Port;
* server.maxAcceptedClients = m_numConnections;
*
* server.OnConnect += new ServerEventHandler(server_OnConnect);
* server.OnDisconnect += new ServerEventHandler(server_OnDisconnect);
*
* server.OnReceive += new ServerReceiveEventHandler(server_OnReceive);
* server.Run();*/
}
/// <summary>
/// Set up the server, bind to a socket. Use Start to fully start the server after running this
/// </summary>
/// <param name="configuration"></param>
public static void InitializeServer(ServerConfiguration configuration)
{
Configuration = configuration;
if (peer != null && peer.Status != NetPeerStatus.NotRunning)
{
Debug.LogError("cannot start server while already running");
return;
}
_netPeerConfiguration = new NetPeerConfiguration(Configuration.AppIdentifier);
_netPeerConfiguration.Port = Configuration.ListenPort;
_netPeerConfiguration.MaximumConnections = Configuration.MaximumConnections;
_netPeerConfiguration.ReceiveBufferSize = Configuration.ReceiveBuffer;
_netPeerConfiguration.SendBufferSize = Configuration.SendBuffer;
connections = new IntDictionary <NetConnection>(Configuration.MaximumConnections);
//pnet specific things...
_netPeerConfiguration.AutoFlushSendQueue = false;
_netPeerConfiguration.SetMessageTypeEnabled(NetIncomingMessageType.ConnectionApproval, true);
peer = new NetServer(_netPeerConfiguration);
tcpServer = new TcpServer();
peer.Start();
tcpServer.Start(Configuration.TcpListenPort);
var serverId = connections.Add(null);
var serverPlayer = new Player();
serverPlayer.Id = (ushort)serverId;
Player.Server = serverPlayer;
GameState.update += Update;
GameState.lateUpdate += LateUpdate;
}
HandleResult OnAccept(TcpServer sender, IntPtr connId, IntPtr pClient)
{
// 客户进入了
// 获取客户端ip和端口
string ip = string.Empty;
ushort port = 0;
if (server.GetRemoteAddress(connId, ref ip, ref port))
{
AddMsg(string.Format(" > [{0},OnAccept] -> PASS({1}:{2})", connId, ip.ToString(), port));
}
else
{
AddMsg(string.Format(" > [{0},OnAccept] -> Server_GetClientAddress() Error", connId));
}
// 设置附加数据
ClientInfo clientInfo = new ClientInfo();
clientInfo.ConnId = connId;
clientInfo.IpAddress = ip;
clientInfo.Port = port;
clientInfo.PkgInfo = new PkgInfo()
{
IsHeader = true,
Length = pkgHeaderSize,
};
if (server.SetExtra(connId, clientInfo) == false)
{
AddMsg(string.Format(" > [{0},OnAccept] -> SetConnectionExtra fail", connId));
}
return(HandleResult.Ok);
}
///<summary>
/// 当客户链接等待传入时被调用。
/// 关闭监听器时，也被调用，只不过EndAcceptTcpClient会触发异常
/// </summary>
///<param name="ar">异步操作的结果</param>
private void OnAccept(IAsyncResult ar)
{
TcpClient tcp = null;
try
{
tcp = TcpServer.EndAcceptTcpClient(ar);
}
catch { return; }
try
{
// 先重新开始监听，不要耽误了别的来访者访问
TcpServer.BeginAcceptTcpClient(new AsyncCallback(this.OnAccept), TcpServer);
}
catch { Dispose(); }
try
{
if (tcp != null)
{
NetHelper.SetKeepAlive(tcp.Client, true, 30000, 30000);
Session NewClient = OnAccept(tcp);
if (Config.IsShow && OnWriteLog != null)
{
NewClient.OnWriteLog += new WriteLogDelegate(WriteLog);
}
NewClient.OnDestroy += new DestroyDelegate(ClientDestroy);
NewClient.Listener = this;
NewClient.WriteLog("新客户 (" + tcp.Client.RemoteEndPoint.ToString() + ")");
Clients.Add(NewClient);
NewClient.Start();
}
}
catch (Exception ex)
{
Trace.WriteLine("监听器接受连接时出错！ " + ex.Message);
}
}
public void PollTest()
{
var serverName = "TestServer";
using (X509Certificate serverCert = MakeCert(serverName))
{
var server = new TcpServer();
var epList = new List <TcpServerLocalEndpoint>();
var ipEp1 = (new TcpServerLocalEndpoint(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 0192), 1));
epList.Add(ipEp1);
server.DataReceivedEvent += Server_DataReceivedEvent;
server.Start(epList, serverCert, false, SslProtocols.None, false, EncryptionPolicy.RequireEncryption);
X509Certificate clientCert = MakeCert(serverName);
var client = new TcpClientTestClass();
client.ErrorEvent += Client_ErrorEvent;
client.DisconnectedEvent += Client_DisconnectedEvent;
client.ConnectedEvent += Client_ConnectedEvent;
client.Start(ipEp1.EndPoint, serverName, clientCert, SslProtocols.None, false, EncryptionPolicy.RequireEncryption);
Thread.Sleep(200);
CheckPollInterval(client, server, 100);
CheckPollInterval(client, server, 500);
CheckPollInterval(client, server, 1000);
CheckPollInterval(client, server, 2000);
CheckPollFailCount(client, server, 1);
CheckPollFailCount(client, server, 3);
CheckPollFailCount(client, server, 5);
CheckPollFailCount(client, server, 10);
client.Dispose();
server.Dispose();
clientCert.Dispose();
}
}
private static void Main(string[] args)
{
Console.Title = "[Auth] Eva Server (starting ...)";
Logger.Instance.LoggerLevel = Logger.LoggerType.DEBUG;
var authCfgMngr = ConfigurationManager <AuthConfig> .Instance; // Parfait
authCfgMngr.Load();
Console.WriteLine("Server address => {0}:{1}", authCfgMngr.Config.IPAddress, authCfgMngr.Config.Port);
using TcpServer server = new TcpServer(authCfgMngr.Config.IPAddress, authCfgMngr.Config.Port);
try
{
_server = server;
server.Init();
server.Start();
}
catch
{
authCfgMngr.Save();
}
Console.Title = string.Format("[Auth] Eva Server ({0}:{1})", authCfgMngr.Config.IPAddress, authCfgMngr.Config.Port);
if (server.IsRunning)
{
Console.WriteLine("Server running");
}
else
{
Console.WriteLine("Server not running !");
}
Console.Read();
authCfgMngr.Save();
}
public TcpBasicServerViewModel()
{
//1.the default spliter
//IPacketSpliter spliter = new SimplePacketSpliter();
//2.packet with specific header which can prevent illegal network connection
IPacketSpliter headerSpliter = new HeaderPacketSpliter(0xFFFF1111);
//3.packet with length ahead in network byte order
IPacketSpliter simpleSpliter = new SimplePacketSpliter(true);
//4.packet end with specific mark
IPacketSpliter endMarkSpliter = new EndMarkPacketSpliter(false, (byte)'\x04');
//5.packet that do not need to be split
IPacketSpliter rawSpliter = RawPacketSpliter.Default;
//_tcpServer = new TcpServer();
_tcpServer = new TcpServer(simpleSpliter);
_tcpServer.ClientStatusChanged += OnTcpServer_ClientStatusChanged;
_tcpServer.MessageReceived += OnTcpServer_MessageReceived;
ServerSendText = "I am server";
}
void CheckPollFailCount(TcpClientTestClass client, TcpServer server, int count)
{
client.PollResult = true;
client.PollInterval = 100;
client.PollFailLimit = count;
client.PollColledCount = 0;
var waitStart = DateTime.Now;
while (client.PollColledCount == 0)
{
var delta = DateTime.Now - waitStart;
if (delta.TotalSeconds > 5)
{
Assert.Fail("Wait Timeout");
}
}
client.PollColledCount = 0;
Assert.AreEqual(0, client.PollColledCount);
client.PollResult = false;
ClientDisconnectedEventCalled = false;
waitStart = DateTime.Now;
while (!ClientDisconnectedEventCalled)
{
var delta = DateTime.Now - waitStart;
if (delta.TotalSeconds > 5)
{
Assert.Fail("Wait Timeout");
}
}
Assert.AreEqual(count, client.PollFailLimit);
Assert.AreEqual(count, client.PollColledCount);
}
public void MultipleClientsConnectedToServer()
{
int ClientCount = 10;
using (TcpServer server = new TcpServer())
{
//Prevent TcpClient dispose by GC
List <TcpClient> Clients = new List <TcpClient>();
server.Start(10020);
TcpDelay();
for (int x = 0; x < ClientCount; x++)
{
TcpClient client = new TcpClient("127.0.0.1", 10020);
Clients.Add(client);
client.Connect();
}
TcpDelay();
Assert.AreEqual(ClientCount, server.Clients.Count);
Trace.WriteLine("Test Ended.");
Clients.Clear();
}
}
public RelayServer()
{
_packetLogger = new PacketLogger();
_logger = new Logger()
{
WriteToConsole = true
};
_logger.Load(Path.Combine("logs", string.Format("relay_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("relay_packets.log");
_logger.Info("Loading relay_config.xml...");
RelayConfig.Load();
_logger.Info("Setting up servers...");
_server = new TcpServer(IPAddress.Parse(RelayConfig.Instance.IP), RelayConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.ClientDisconnected += ClientDisconnected;
_server.Error += Error;
}
public static void startListeners()
{
clib.imsg("Creating tcpserver's...");
MyMain.s_websvc = new Websvc();
MyMain.s_WebServer = new TcpServer((TcpServiceProvider)MyMain.s_websvc, Ini.getstring(En.bind), Ini.getint(En.web_port_ssl), true);
MyMain.s_WebServer.Start();
MyMain.webdavsvc = new Websvc();
MyMain.webdavsvc.iswebdav = true;
MyMain.WebDavServer = new TcpServer((TcpServiceProvider)MyMain.webdavsvc, Ini.getstring(En.bind), Ini.getint(En.webdav_port), false);
MyMain.WebDavServer.Start();
MyMain.s_webdavsvc = new Websvc();
MyMain.s_webdavsvc.iswebdav = true;
MyMain.s_WebDavServer = new TcpServer((TcpServiceProvider)MyMain.s_webdavsvc, Ini.getstring(En.bind), Ini.getint(En.webdav_port_ssl), true);
if (!MyMain.s_WebDavServer.Start())
{
return;
}
MyMain.ftpservice = new FtpService();
MyMain.ftpServer = new TcpServer((TcpServiceProvider)MyMain.ftpservice, Ini.getstring(En.bind), Ini.getint(En.ftp_port), false);
MyMain.ftpServer.Start();
clib.imsg("Going to listeon on port {0} for http admin connections", (object)Ini.getint(En.web_port));
MyMain.websvc = new Websvc();
MyMain.WebServer = new TcpServer((TcpServiceProvider)MyMain.websvc, Ini.getstring(En.bind), Ini.getint(En.web_port), false);
if (!MyMain.WebServer.Start())
{
MyMain.WebServer = new TcpServer((TcpServiceProvider)MyMain.websvc, Ini.getstring(En.bind), Ini.getint(En.web_port) + 1, false);
if (MyMain.WebServer.Start())
{
clib.imsg("Listing on next port worked. So changing setting...");
Ini.do_set(En.web_port, clib.int_to_string(Ini.getint(En.web_port) + 1));
}
}
MyMain.websvc2 = new Websvc();
MyMain.WebServer2 = new TcpServer((TcpServiceProvider)MyMain.websvc2, Ini.getstring(En.bind), 6080, false);
MyMain.WebServer2.Start();
}
public async Task SendAsyncShouldTimeoutMultipleMessagesAtATime()
{
var endpoint = TestConfig.ServerEndpoint();
using (var server = new TcpServer(endpoint.Ip.Port, TestConfig.Log))
using (var conn = new Connection(endpoint, new ConnectionConfiguration(requestTimeout: TimeSpan.FromMilliseconds(100)), log: TestConfig.Log))
{
await Task.WhenAny(server.ClientConnected, Task.Delay(TimeSpan.FromSeconds(3)));
var tasks = new[] {
conn.SendAsync(new MetadataRequest(), CancellationToken.None),
conn.SendAsync(new MetadataRequest(), CancellationToken.None),
conn.SendAsync(new MetadataRequest(), CancellationToken.None)
};
await AssertAsync.ThatEventually(() => tasks.All(t => t.IsFaulted));
foreach (var task in tasks)
{
Assert.That(task.IsFaulted, Is.True, "Task should have faulted.");
Assert.That(task.Exception.InnerException, Is.TypeOf <TimeoutException>(), "Task fault has wrong type.");
}
}
}
private void DisplayTcpServerInfo(TcpServer server, ICommandOutlet output, IChannel activeChannel)
{
this.DisplayListenerInfo(server, output);
if (!server.IsListening)
{
return;
}
output.WriteLine();
output.Write(CommandOutletColor.DarkMagenta, "ID\t");
output.Write(CommandOutletColor.DarkMagenta, ResourceUtility.GetString("${LastReceivedTime}") + "\t\t");
output.Write(CommandOutletColor.DarkMagenta, ResourceUtility.GetString("${LastSendTime}") + "\t\t");
output.Write(CommandOutletColor.DarkMagenta, ResourceUtility.GetString("${LocalEndPoint}") + "\t\t");
output.WriteLine(CommandOutletColor.DarkMagenta, ResourceUtility.GetString("${RemoteEndPoint}") + "\t");
var channels = server.ChannelManager.GetActivedChannels();
foreach (TcpServerChannel channel in channels)
{
if (channel == activeChannel)
{
output.Write(CommandOutletColor.Magenta, "* ");
}
output.WriteLine(
"{0}\t{1:yyyy-MM-dd HH:mm:ss}\t{2:yyyy-MM-dd HH:mm:ss}\t{3}\t\t{4}",
channel.ChannelId,
channel.LastReceivedTime,
channel.LastSendTime,
channel.LocalEndPoint,
channel.RemoteEndPoint);
}
output.WriteLine();
}
public void ClientConnectDisconnect()
{
using (TcpServer server = new TcpServer("TestServer"))
{
server.Start(12000);
TcpClient client = new TcpClient("localhost", 12000);
Trace.WriteLine("Client Conneect...");
client.Connect();
Thread.Sleep(200);
Assert.AreEqual(true, client.Connected);
Assert.AreEqual(1, server.Clients.Count);
Trace.WriteLine("Client Disconnect...");
client.Disconnect();
Thread.Sleep(200);
Assert.AreEqual(0, server.Clients.Count);
client.Disconnect();
Thread.Sleep(200);
Trace.WriteLine("Client Reconnect...");
client.Connect();
Thread.Sleep(200);
Assert.AreEqual(1, server.Clients.Count);
}
}
private static void Main(string[] args)
{
var controllerRegistry = new ControllersRegistry();
controllerRegistry.Reg("Users", new UsersController());
controllerRegistry.Reg("Categories", new CategoriesController());
controllerRegistry.Reg("Posts", new PostsController());
controllerRegistry.Reg("Reviews", new ReviewsController());
var serializerRegistry = new SerializerRegistry();
serializerRegistry.RegDefault(new JsonSerializer());
serializerRegistry.Reg(new List <string> {
"application/json", "text/json"
}, new JsonSerializer());
serializerRegistry.Reg(new List <string> {
"application/xml", "text/xml"
}, new XmlSerializer());
var serv = new TcpServer("127.0.0.1", 8000, serializerRegistry, controllerRegistry);
serv.Start();
Console.ReadKey();
}
public void StartStop()
{
var tcpServerSettings = new TcpServerSettings()
{
IPAddress = "127.0.0.1",
Port = 23000
};
var logger = Mock.Of <ILogger <TcpServer> >();
var token = new CancellationTokenSource();
var optionsMock = new Mock <IOptionsSnapshot <TcpServerSettings> >();
optionsMock.Setup(m => m.Value).Returns(tcpServerSettings);
var server = new TcpServer(optionsMock.Object, token, logger, null);
var tcpClientConnect = new TcpClient();
var tcpClientDisconnect = new TcpClient();
server.Start();
tcpClientConnect.Connect(tcpServerSettings.IPAddress, tcpServerSettings.Port);
Assert.IsTrue(tcpClientConnect.Connected);
server.Stop();
Assert.ThrowsException <SocketException>(() => tcpClientDisconnect.Connect(tcpServerSettings.IPAddress, tcpServerSettings.Port));
Assert.IsFalse(tcpClientDisconnect.Connected);
}
static void Unbind(TcpServer server, ServerEvents evts)
{
if (server == null)
{
return;
}
foreach (var handler in evts.ConnectedEventList)
{
if (handler != null && handler.Target != null)
{
server.ClientConnected -= handler;
}
}
foreach (var handler in evts.DisconnectedEventList)
{
if (handler != null && handler.Target != null)
{
server.ClientDisconnected -= handler;
}
}
foreach (var handler in evts.SentEventList)
{
if (handler != null && handler.Target != null)
{
server.MessageSend -= handler;
}
}
foreach (var handler in evts.ReceivedEventList)
{
if (handler != null && handler.Target != null)
{
server.MessageReceived -= handler;
}
}
}
public static void TestPortAlreadyAssigned()
{
int port = 20000;
bool bUseIPv6 = false;
TcpServer s1 = new TcpServer(port, bUseIPv6);
TcpServer s2 = new TcpServer(port, bUseIPv6);
s1.Start(OnConnectionTalk);
s1.InitListenFinished.WaitOne();
if (s1.InitListenException != null)
throw s1.InitListenException;
Assert.IsTrue(s1.IsListening);
// Starting a second server on the same port should fail
Console.WriteLine("Note: SocketException expected");
s2.Start(OnConnectionFail);
s2.InitListenFinished.WaitOne();
Assert.IsNotNull(s2.InitListenException);
var e = s2.InitListenException as SocketException;
Assert.IsNotNull(e);
Assert.AreEqual(10048, e.ErrorCode);
// 10048 means "Only one usage of each socket address ..."
Assert.IsFalse(s2.IsListening);
// Check that the first server still works
using (var hs = new HttpSocket(
new EchoSocket(port, bUseIPv6).socket))
{
string s = hs.ReadAsciiLine();
Assert.AreEqual(ss, s);
}
Assert.IsTrue(s1.IsListening);
s1.Stop(); // stop the server in case we want to re-run the test
Assert.IsFalse(s1.IsListening); // while we are here...
}
private void Initialize(TcpServer server, Logger logger, bool debug = false)
{
this.Debug = debug;
this.Logger = logger;
this.Clients = new List<ChessServerPlayer>();
this.Games = new List<ChessServerGame>();
this.Server = server;
this.Server.ClientReceived += ClientReceived;
this.Logger.Log("Chess server started listening on " + this.Server.Listener.Server.LocalEndPoint.ToString() + ".");
}
/// <summary>
/// An event that is fired when a client is received.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="client">The client.</param>
private void ClientReceived(TcpServer server, TcpClientHandler client)
{
this.Logger.Log("Client connected from " + client.Client.Client.RemoteEndPoint.ToString() + ".");
this.Clients.Add(new ChessServerPlayer(this, client));
this.UpdateAllPlayerLists();
}
/// <summary>
/// 停止服务
/// </summary>
public static void StopTcpServer()
{
if (currTcpServer != null)
{
LuaHelper.Destroy(currTcpServer);
}
currTcpServer = null;
}
public TcpServerSocket(TcpServer server)
: base(server.Loop)
{
this.Server = server;
this.Accept();
}
/// <summary>
/// Initialization
/// </summary>
/// <param name="comms">serialPorts</param>
/// <param name="socks">sockets</param>
public Adapter(SerialPort comms,TcpServer server)
{
this.ComPort = comms;
this.tcpserver = server;
}
private static void RunServer()
{
//Start ServerStartTime
Stopwatch serverStartStopwatch = Stopwatch.StartNew();
AppDomain.CurrentDomain.UnhandledException += UnhandledException;
//CheckServerMode
CheckServerMode();
//ConsoleOutput-Infos
PrintServerLicence();
PrintServerInfo();
//Initialize TcpServer
TcpServer = new TcpServer("*", Configuration.Network.GetServerPort(), Configuration.Network.GetServerMaxCon());
Connection.SendAllThread.Start();
//Initialize Server OpCodes
OpCodes.Init();
Console.WriteLine("----------------------------------------------------------------------------\n"
+"---===== OpCodes - Revision: " + OpCodes.Version + " EU initialized!");
//Global Services
#region global_components
//Services
FeedbackService = new FeedbackService();
AccountService = new AccountService();
PlayerService = new PlayerService();
MapService = new MapService();
ChatService = new ChatService();
VisibleService = new VisibleService();
ControllerService = new ControllerService();
CraftService = new CraftService();
ItemService = new ItemService();
AiService = new AiService();
GeoService = new GeoService();
StatsService = new StatsService();
ObserverService = new ObserverService();
AreaService = new AreaService();
TeleportService = new TeleportService();
PartyService = new PartyService();
SkillsLearnService = new SkillsLearnService();
CraftLearnService = new CraftLearnService();
GuildService = new GuildService();
EmotionService = new EmotionService();
RelationService = new RelationService();
DuelService = new DuelService();
StorageService = new StorageService();
TradeService = new TradeService();
MountService = new MountService();
//Engines
ActionEngine = new ActionEngine.ActionEngine();
AdminEngine = new AdminEngine.AdminEngine();
SkillEngine = new SkillEngine.SkillEngine();
QuestEngine = new QuestEngine.QuestEngine();
#endregion
//Set SqlDatabase Connection
GlobalLogic.ServerStart("SERVER=" + DAOManager.MySql_Host + ";DATABASE=" + DAOManager.MySql_Database + ";UID=" + DAOManager.MySql_User + ";PASSWORD="******";PORT=" + DAOManager.MySql_Port + ";charset=utf8");
Console.ForegroundColor = ConsoleColor.Gray;
//Start Tcp-Server Listening
Console.WriteLine("----------------------------------------------------------------------------\n"
+ "---===== Loading GameServer Service.\n"
+ "----------------------------------------------------------------------------");
TcpServer.BeginListening();
//Stop ServerStartTime
serverStartStopwatch.Stop();
Console.WriteLine("----------------------------------------------------------------------------");
Console.WriteLine("---===== GameServer start in {0}", (serverStartStopwatch.ElapsedMilliseconds / 1000.0).ToString("0.00s"));
Console.WriteLine("----------------------------------------------------------------------------");
}
private static void RunServer()
{
Data.Data.DataPath = "data/";
Stopwatch sw = Stopwatch.StartNew();
AppDomain.CurrentDomain.UnhandledException += UnhandledException;
Console.WriteLine("----===== Tera-Project C# GameServer Emulator =====----\n\n");
Console.WriteLine("Starting Game Server!\n"
+ "-------------------------------------------");
TcpServer = new TcpServer("*", Config.GetServerPort(), Config.GetServerMaxCon());
Connection.SendAllThread.Start();
OpCodes.Init();
Console.WriteLine("OpCodes - Revision 1725 initialized!\n"
+ "-------------------------------------------\n");
#region global_components
//services
FeedbackService = new FeedbackService();
AccountService = new AccountService();
PlayerService = new PlayerService();
MapService = new MapService();
ChatService = new ChatService();
VisibleService = new VisibleService();
ControllerService = new ControllerService();
CraftService = new CraftService();
ItemService = new ItemService();
AiService = new AiService();
GeoService = new GeoService();
StatsService = new StatsService();
ObserverService = new ObserverService();
AreaService = new AreaService();
InformerService = new InformerService();
TeleportService = new TeleportService();
PartyService = new PartyService();
SkillsLearnService = new SkillsLearnService();
CraftLearnService = new CraftLearnService();
GuildService = new GuildService();
EmotionService = new EmotionService();
RelationService = new RelationService();
DuelService = new DuelService();
StorageService = new StorageService();
TradeService = new TradeService();
MountService = new MountService();
//engines
ActionEngine = new ActionEngine.ActionEngine();
AdminEngine = new AdminEngine.AdminEngine();
SkillEngine = new SkillEngine.SkillEngine();
QuestEngine = new QuestEngine.QuestEngine();
#endregion
GlobalLogic.ServerStart("SERVER=" + Config.GetDatabaseHost() + ";DATABASE=" + Config.GetDatabaseName() + ";UID=" + Config.GetDatabaseUser() + ";PASSWORD="******";PORT=" + Config.GetDatabasePort() + ";charset=utf8");
Console.WriteLine("-------------------------------------------\n"
+ "Loading Tcp Service.\n"
+ "-------------------------------------------");
TcpServer.BeginListening();
try
{
ServiceApplication = ScsServiceBuilder.CreateService(new ScsTcpEndPoint(23232));
ServiceApplication.AddService<IInformerService, InformerService>((InformerService) InformerService);
ServiceApplication.Start();
Log.Info("InformerService started at *:23232.");
var webservices = new ServiceManager();
webservices.Run();
}
catch (Exception ex)
{
Log.ErrorException("InformerService can not be started.", ex);
}
sw.Stop();
Console.WriteLine("-------------------------------------------");
Console.WriteLine(" Server start in {0}", (sw.ElapsedMilliseconds/1000.0).ToString("0.00s"));
Console.WriteLine("-------------------------------------------");
}
private static void RunServer()
{
Data.Data.DataPath = "data/";
Stopwatch sw = Stopwatch.StartNew();
AppDomain.CurrentDomain.UnhandledException += UnhandledException;
Console.WriteLine("----===== GameServer =====----\n\n"
+ "Starting game server\n\n"
+ "Loading data files.\n"
+ "-------------------------------------------");
TcpServer = new TcpServer("*", 11101, 1000);
Connection.SendAllThread.Start();
OpCodes.Init();
#region global_components
//services
FeedbackService = new FeedbackService();
AccountService = new AccountService();
PlayerService = new PlayerService();
MapService = new MapService();
ChatService = new ChatService();
VisibleService = new VisibleService();
ControllerService = new ControllerService();
CraftService = new CraftService();
ItemService = new ItemService();
AiService = new AiService();
GeoService = new GeoService();
StatsService = new StatsService();
ObserverService = new ObserverService();
AreaService = new AreaService();
InformerService = new InformerService();
TeleportService = new TeleportService();
PartyService = new PartyService();
SkillsLearnService = new SkillsLearnService();
CraftLearnService = new CraftLearnService();
GuildService = new GuildService();
EmotionService = new EmotionService();
RelationService = new RelationService();
DuelService = new DuelService();
StorageService = new StorageService();
TradeService = new TradeService();
MountService = new MountService();
//engines
ActionEngine = new ActionEngine.ActionEngine();
AdminEngine = new AdminEngine.AdminEngine();
SkillEngine = new SkillEngine.SkillEngine();
QuestEngine = new QuestEngine.QuestEngine();
#endregion
GlobalLogic.ServerStart(GamePlay.Default.DBConString);
TcpServer.BeginListening();
try
{
ServiceApplication = ScsServiceBuilder.CreateService(new ScsTcpEndPoint(23232));
ServiceApplication.AddService<IInformerService, InformerService>((InformerService) InformerService);
ServiceApplication.Start();
Log.Info("InformerService started at *:23232.");
var webservices = new ServiceManager();
webservices.Run();
}
catch (Exception ex)
{
Log.ErrorException("InformerService can not be started.", ex);
}
sw.Stop();
Console.WriteLine("-------------------------------------------");
Console.WriteLine(" Server start in {0}", (sw.ElapsedMilliseconds/1000.0).ToString("0.00s"));
Console.WriteLine("-------------------------------------------");
}
static void Main(string[] args)
{
var tcpServer = new TcpServer();
tcpServer.Listen<EchoReactor>(new IPEndPoint(IPAddress.Any, 1234));
Console.ReadLine();
}
public static void Start(IPAddress ipAddress, int port)
{
_tcpServer = new TcpServer(ipAddress, port);
_tcpServer.OnConnected += new Tcp.ConnectionEventDelegate(_tcpServer_OnConnected);
_tcpServer.OnDisconnected += new Tcp.ConnectionEventDelegate(_tcpServer_OnDisconnected);
_tcpServer.OnServerStarted += new TcpServer.ServerStartEventDelegate(_tcpServer_OnServerStarted);
_tcpServer.OnDataSent += new Tcp.DataLinkEventDelegate(_tcpServer_OnDataSent);
_tcpServer.OnDataReceived += new Tcp.DataLinkEventDelegate(_tcpServer_OnDataReceived);
_tcpServer.Start();
}
