// Initialize all of the default certificates and protocols
public SslServer()
{
// Initialize the Socket
serverSocketType = SocketType.Stream;
serverProtocolType = ProtocolType.Tcp;
if (Microsoft.SPOT.Hardware.SystemInfo.SystemID.SKU == 3)
{
cert = new X509Certificate(CertificatesAndCAs.emuCert, "NetMF");
ca = new X509Certificate[] { new X509Certificate(CertificatesAndCAs.caEmuCert) };
}
else
{
// Initialize the SslStream
cert = new X509Certificate(CertificatesAndCAs.newCert);
ca = new X509Certificate[] { new X509Certificate(CertificatesAndCAs.caCert) };
}
verify = SslVerification.NoVerification;
sslProtocols = new SslProtocols[] { SslProtocols.Default };
// Create a TCP/IP (IPv4) socket and listen for incoming connections.
serverSocket = new Socket(AddressFamily.InterNetwork, serverSocketType, serverProtocolType);
serverSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, false);
serverSocket.Bind(new IPEndPoint(IPAddress.Loopback, 0));
serverEp = (IPEndPoint)serverSocket.LocalEndPoint;
Debug.Print("Listening for a client to connect...");
serverSocket.Listen(1);
}
public server_socket( Object name, int port )
: base()
{
try {
/* _server_socket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp ); */
/* _server_socket.Bind( new IPEndPoint( 0, port ) ); */
IPEndPoint endpoint;
if( name != bigloo.foreign.BFALSE ) {
String server = bigloo.foreign.newstring( name );
IPHostEntry host = Dns.Resolve(server);
IPAddress address = host.AddressList[0];
endpoint = new IPEndPoint(address, port);
} else {
endpoint = new IPEndPoint( 0, port );
}
_server_socket = new Socket( endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp );
_server_socket.Bind( endpoint );
_server_socket.Listen( 10 );
}
catch (Exception e) {
socket_error( "make-server-socket",
"cannot create socket (" + e.Message + ")",
new bint( port ) );
}
}
public EndPointListener(
IPAddress address, int port, bool secure, string certFolderPath, X509Certificate2 defaultCert)
{
if (secure)
{
_secure = secure;
_cert = getCertificate(port, certFolderPath, defaultCert);
if (_cert == null)
{
throw new ArgumentException("No server certificate found.");
}
}
_endpoint = new IPEndPoint(address, port);
_prefixes = new Dictionary <ListenerPrefix, HttpListener> ();
_unregistered = new Dictionary <HttpConnection, HttpConnection> ();
_socket = new System.Net.Sockets.Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
_socket.Bind(_endpoint);
_socket.Listen(500);
var args = new SocketAsyncEventArgs();
args.UserToken = this;
args.Completed += onAccept;
_socket.AcceptAsync(args);
}
public void Start(IPAddress address, int?port)
{
var localEndPoint = new IPEndPoint(address, port.HasValue ? port.Value : DEFAULT_PORT);
_socket = new System.Net.Sockets.Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
_socket.Bind(localEndPoint);
_socket.Listen(BACKLOG);
Console.WriteLine("Server started. Listening to TCP clients at {0}:{1}", address.ToString(), localEndPoint.Port);
while (true)
{
_event.Reset();
_socket.BeginAccept(new AsyncCallback(AcceptCallback), this);
Console.WriteLine("Waiting for a connection...");
_event.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public override void Start()
{
if (!Disposed)
{
FSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
FSocket.Bind(LocalEndPoint);
FSocket.Listen(FBackLog * FAcceptThreads);
//----- Begin accept new connections!
int loopCount = 0;
SocketAsyncEventArgs e = null;
for (int i = 1; i <= FAcceptThreads; i++)
{
e = new SocketAsyncEventArgs();
e.UserToken = this;
e.Completed += new EventHandler <SocketAsyncEventArgs>(BeginAcceptCallbackAsync);
if (!FSocket.AcceptAsync(e))
{
BeginAcceptCallbackAsync(this, e);
}
;
ThreadEx.LoopSleep(ref loopCount);
}
}
}
/// <summary>
/// Listen to incoming data
/// </summary>
public void Listen()
{
//IPAddress ipAddr = IPAddress.Parse("10.241.129.147");
IPHostEntry ipHost = Dns.GetHostEntry("localhost");
IPAddress ipAddr = ipHost.AddressList[0];
IPEndPoint ipEndPoint = new IPEndPoint(ipAddr, 5050);
Socket sListener = new Socket(ipAddr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
sListener.Bind(ipEndPoint);
sListener.Listen(10);
while (true)
{
Console.WriteLine("Ожидаем соединение через порт {0}", ipEndPoint);
Socket handler = sListener.Accept();
RecieveDict(handler);
handler.Shutdown(SocketShutdown.Both);
handler.Close();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
finally
{
Console.ReadLine();
}
}
internal void Bind()
{
if (_listenSocket != null)
{
throw new InvalidOperationException("Transport already bound");
}
var listenSocket = new System.Net.Sockets.Socket(EndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
listenSocket.EnableFastPath();
// Kestrel expects IPv6Any to bind to both IPv6 and IPv4
if (EndPoint is IPEndPoint ip && ip.Address == IPAddress.IPv6Any)
{
listenSocket.DualMode = true;
}
try
{
listenSocket.Bind(EndPoint);
}
catch (SocketException e) when(e.SocketErrorCode == SocketError.AddressAlreadyInUse)
{
throw new AddressInUseException(e.Message, e);
}
EndPoint = listenSocket.LocalEndPoint;
listenSocket.Listen(512);
_listenSocket = listenSocket;
}
public void run()
{
IPEndPoint ipep = new IPEndPoint(IPAddress.Any, ChatSetting.port);
Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
newsock.Bind(ipep);
newsock.Listen(10);
while (true)
{
Socket socket = newsock.Accept();
Console.WriteLine("�����@�ӷs�s�u!");
ChatSocket client = new ChatSocket(socket);
try
{
clientList.Add(client);
client.newListener(processMsgComeIn);
}
catch
{
}
// clientList.Remove(client);
}
// newsock.Close();
}
// (1) Establish The Server
public string Start_A_Server_On(int Port)
{
try
{
IPAddress[] AddressAr = null;
String ServerHostName = "";
try
{
ServerHostName = Dns.GetHostName();
IPHostEntry ipEntry = Dns.GetHostByName(ServerHostName);
AddressAr = ipEntry.AddressList;
}
catch (Exception) { }
if (AddressAr == null || AddressAr.Length < 1)
{
return "Unable to get local address ... Error";
}
Listener_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Listener_Socket.Bind(new IPEndPoint(AddressAr[0], Port));
Listener_Socket.Listen(-1);
Listener_Socket.BeginAccept(new AsyncCallback(EndAccept), Listener_Socket);
return ("Listening On " + AddressAr[0].ToString() + ":" + Port + "... OK");
}
catch (Exception ex) { return ex.Message; }
}
internal void Listen(String ipAddress, Int32 portNo)
{
if (_isRunning == true)
throw new AegisException(ResultCode.AcceptorIsRunning, "Acceptor is already running.");
try
{
if (ipAddress.Length == 0)
_listenEndPoint = new IPEndPoint(IPAddress.Any, portNo);
else
_listenEndPoint = new IPEndPoint(IPAddress.Parse(ipAddress), portNo);
_listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listenSocket.Bind(_listenEndPoint);
_listenSocket.Listen(100);
Logger.Write(LogType.Info, 1, "Listening on {0}, {1}", _listenEndPoint.Address, _listenEndPoint.Port);
_isRunning = true;
(new Thread(Run)).Start();
}
catch (Exception e)
{
throw new AegisException(ResultCode.NetworkError, e, e.Message);
}
}
private void OnClientConnect(IAsyncResult AcceptAsync)
{
try
{
Socket Sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Sock = ListenerSock.EndAccept(AcceptAsync);
Server ServerSock = new Server(Sock);
//RaiseEvent if event is linked
if (Connected != null)
{
Connected(ServerSock);
}
}
catch
{
}
finally
{
ListenerSock.Dispose();
ListenerSock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress hostIP = (Dns.Resolve(IPAddress.Any.ToString())).AddressList[0];
ListenerSock.Bind(new IPEndPoint(hostIP, m_Port));
ListenerSock.Listen(0);
ListenerSock.BeginAccept(new AsyncCallback(OnClientConnect), null);
}
}
internal void Bind()
{
if (_listenSocket != null)
{
throw new InvalidOperationException("Transport is already bound.");
}
System.Net.Sockets.Socket listenSocket;
// Unix domain sockets are unspecified
var protocolType = EndPoint is UnixDomainSocketEndPoint ? ProtocolType.Unspecified : ProtocolType.Tcp;
listenSocket = new System.Net.Sockets.Socket(EndPoint.AddressFamily, SocketType.Stream, protocolType);
// Kestrel expects IPv6Any to bind to both IPv6 and IPv4
if (EndPoint is IPEndPoint ip && ip.Address == IPAddress.IPv6Any)
{
listenSocket.DualMode = true;
}
try {
listenSocket.Bind(EndPoint);
} catch (SocketException e) when(e.SocketErrorCode == SocketError.AddressAlreadyInUse)
{
throw new AddressInUseException(e.Message, e);
}
EndPoint = listenSocket.LocalEndPoint;
listenSocket.Listen(512);
_listenSocket = listenSocket;
}
void connect()
{
CLientList = new List <System.Net.Sockets.Socket>();
//ip la dia chi cua server.
IP = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 9999);
server = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, SocketType.Stream, System.Net.Sockets.ProtocolType.IP);
server.Bind(IP);
System.Threading.Thread Listen = new System.Threading.Thread(() => {
try
{
while (true)
{
server.Listen(100);
Socket client = server.Accept();
CLientList.Add(client);
System.Threading.Thread receive1 = new System.Threading.Thread(Receive);
receive1.IsBackground = true;
receive1.Start(client);
}
}
catch
{
IP = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 9999);
server = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, SocketType.Stream, System.Net.Sockets.ProtocolType.IP);
}
});
Listen.IsBackground = true;
Listen.Start();
}
static void Main(string[] args)
{
//1.创建socket
Socket tpcServer = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
//2.绑定ip跟端口号 192.168.1.105
IPAddress ipaddress = new IPAddress(new byte[]{192,168,1,105});
EndPoint point = new IPEndPoint(ipaddress,7788);//ipendpoint 是对ip + 端口做了一层封装的类
tpcServer.Bind(point); //向操作系统申请一个可用的ip跟端口号 用来做通信
//3.开始监听 (等待客户端连接)
tpcServer.Listen(100); //参数是最大连接数
Console.WriteLine("开始监听");
Socket clientSocket = tpcServer.Accept(); //暂停当前的线程，直到有一个客户端连接过来，之后进行下面的代码
//使用返回的socket跟客户端做通信
Console.WriteLine("客户端连接过来了");
string message = "hello 欢迎你 ";
byte[] data = Encoding.UTF8.GetBytes(message);//对字符串做编码，得到一个字符串的字节数组
clientSocket.Send(data);
Console.WriteLine("向客户端发送数据");
byte[] data2 = new byte[1024]; //创建一个字节数组用来做容器，去承接客户端发送过来的数据
int length = clientSocket.Receive(data2);
string message2 = Encoding.UTF8.GetString(data2, 0, length);// 把字节数转化成一个字符串
Console.WriteLine("接收到了一个从客户端发送过来的消息");
Console.WriteLine(message2);
Console.ReadKey();
}
public ClientThread()
{
listenPort = SRLibFun.StringConvertToInt32(SRConfig.Instance.GetAppString("Port"));
socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socketWatch.Bind(new IPEndPoint(GetIP(), listenPort));
socketWatch.Listen(10);
}
public SocketManager(
ILogger logger,
IOptions <SocketOptions> options)
{
foreach (var socketAddress in options.Value.SocketAddresses)
{
var ipAddress = IPAddress.Parse(socketAddress.HostName);
var ipEndPoint = new IPEndPoint(ipAddress, socketAddress.Port);
//创建服务器Socket对象，并设置相关属性
var socket = new System.Net.Sockets.Socket(
socketAddress.AddressFamily,
socketAddress.SocketType,
socketAddress.ProtocolType
);
//绑定ip和端口
socket.Bind(ipEndPoint);
//设置最长的连接请求队列长度
socket.Listen(socketAddress.MaxBacklog);
var clientSocket = new SocketClient()
{
Socket = socket,
SocketAddress = socketAddress
};
SocketClients.Enqueue(clientSocket);
logger.LogInformation($"Socket:" +
$"{socketAddress.FullName} " +
$"{socketAddress.HostName}:" +
$"{socketAddress.Port} 注册监听成功");
}
}
static void Main(string[] args)
{
Socket tcpServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
string StrIp = "192.168.2.72";
// 绑定ip.
tcpServer.Bind(new IPEndPoint(IPAddress.Parse(StrIp), 7788));
// 线程？
tcpServer.Listen(100);
Console.WriteLine("Server running..");
// 死循环？
while (true)
{
Socket clientSocket = tcpServer.Accept();
Console.WriteLine("A client is connected!");
// 把与每个客户端通信的逻辑.(收发消息.) 放到client端里做处理.
Client client = new Client(clientSocket);
clientList.Add(client);
}
}
public bool Start(string host, int port, int backlog)
{
IPAddress address;
if (host == "0.0.0.0")
{
address = IPAddress.Any;
}
else
{
address = IPAddress.Parse(host);
}
IPEndPoint endpoint = new IPEndPoint(address, port);
if (_listenSocket != null)
{
_listenSocket.Close();
_listenSocket = null;
}
_listenSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listenSocket.Bind(endpoint);
_listenSocket.Listen(backlog);
_listenThread.Start();
return(true);
}
//static void Main(string[] args, int a)
public void send()
{
String name = Id.name;
String a1 = "aantal schapen dood";
String a2 = link.a.ToString();
Socket sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sck.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 23));
sck.Listen(0);
Socket acc = sck.Accept();
byte[] buffer = Encoding.Default.GetBytes(name);
byte[] buffer1 = Encoding.Default.GetBytes(a1 + name);
acc.Send(buffer, 0, buffer.Length, 0);
acc.Send(buffer1, 0, buffer.Length, 0);
buffer = new byte[255];
int rec = acc.Receive(buffer, 0, buffer.Length, 0);
Array.Resize(ref buffer, rec);
Console.WriteLine("Received: {0}", Encoding.Default.GetString(buffer));
sck.Close();
acc.Close();
Console.Read();
}
public void Start()
{
IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
Console.WriteLine("IP=" + ipAddress.ToString());
Socket CurrentClient = null;
Socket ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
//On lie la socket au point de communication
ServerSocket.Bind(new IPEndPoint(ipAddress, ProtocoleImplementation.PORT_ID));
//On la positionne en mode "écoute"
ServerSocket.Listen(10);
while (true)
{
Console.WriteLine("Attente d'une nouvelle connexion...");
//L'exécution du thread courant est bloquée jusqu'à ce qu'un nouveau client se connecte
CurrentClient = ServerSocket.Accept();
Console.WriteLine("Nouveau client:" + CurrentClient.GetHashCode());
acceptList.Add(CurrentClient);
SocketServer n = new SocketServer(CurrentClient);
Thread getReadClients = new Thread(new ThreadStart(n.GetQuery));
getReadClients.Start();
}
}
catch (SocketException E)
{
Console.WriteLine(E.Message);
}
}
public void LetListen()
{
ListenButton.Sensitive = false;
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, 8000);
g_listener = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
g_listener.Bind(localEndPoint);
g_listener.Listen(100);
var args = new SocketAsyncEventArgs();
args.Completed += OnAccepted;
StartAccept(args);
Log("Listening has been started");
}
catch (SocketException se)
{
Log((string.Format("StartListening [SocketException] Error : {0} ", se.Message.ToString())));
}
catch (Exception ex)
{
Log((string.Format("StartListening [Exception] Error : {0} ", ex.Message.ToString())));
}
}
/// <summary>
/// Starts to listen
/// </summary>
/// <param name="config">The server config.</param>
/// <returns></returns>
public override bool Start(IServerConfig config)
{
m_ListenSocket = new Socket(this.Info.EndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
m_ListenSocket.Bind(this.Info.EndPoint);
m_ListenSocket.Listen(m_ListenBackLog);
m_ListenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
m_ListenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
//
m_ListenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
SocketAsyncEventArgs acceptEventArg = new SocketAsyncEventArgs();
acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(acceptEventArg_Completed);
if (!m_ListenSocket.AcceptAsync(acceptEventArg))
ProcessAccept(acceptEventArg);
return true;
}
catch (Exception e)
{
OnError(e);
return false;
}
}
public void OpenChannel()
{
var logger = _loggerFactory.CreateLogger($"OpenChannel");
_listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, _port));
_listenSocket.Listen(10);
logger.LogInformation($"Process ID {Process.GetCurrentProcess().Id}");
logger.LogInformation($"Listening on port {_port}");
while (true)
{
var acceptSocket = _listenSocket.Accept();
logger.LogInformation($"Client accepted {acceptSocket.LocalEndPoint}");
var connection = new ConnectionContext(acceptSocket,
_hostName,
_protocolManager,
_workspaceContext,
_projects,
_loggerFactory);
connection.QueueStart();
}
}
private void Form1_Load(object sender, EventArgs e)
{
try
{
//We are using TCP sockets
serverSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
//Assign the any IP of the machine and listen on port number 1000
IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, 1000);
//Bind and listen on the given address
serverSocket.Bind(ipEndPoint);
serverSocket.Listen(4);
//Accept the incoming clients
serverSocket.BeginAccept(new AsyncCallback(OnAccept), null);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "SGSserverTCP",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
static void socket()
{
// (1) 소켓 객체 생성 (TCP 소켓)
System.Net.Sockets.Socket sock = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// (2) 포트에 바인드
IPEndPoint ep = new IPEndPoint(IPAddress.Any, 7000);
sock.Bind(ep);
// (3) 포트 Listening 시작
sock.Listen(10);
// (4) 연결을 받아들여 새 소켓 생성 (하나의 연결만 받아들임)
System.Net.Sockets.Socket clientSock = sock.Accept();
byte[] buff = new byte[8192];
while (!Console.KeyAvailable) // 키 누르면 종료
{
// (5) 소켓 수신
int n = clientSock.Receive(buff);
string data = Encoding.UTF8.GetString(buff, 0, n);
Console.WriteLine(data);
// (6) 소켓 송신
clientSock.Send(buff, 0, n, SocketFlags.None); // echo
}
// (7) 소켓 닫기
clientSock.Close();
sock.Close();
}
public void Start()
{
_layerFactory = new OwinHandlerFactory(_parameters.OwinApp, _parameters.OwinCapabilities);
_ipIsLocalChecker = new IpIsLocalChecker();
_connectionAllocationStrategy = _parameters.ConnectionAllocationStrategy;
var isSsl = _parameters.Certificate != null;
_layerFactory = new Transport2HttpFactory(_parameters.BufferSize, isSsl, _parameters.ServerHeader, _ipIsLocalChecker, _layerFactory);
if (isSsl)
{
_layerFactory = new SslTransportFactory(_parameters, _layerFactory);
}
ListenSocket = new Socket(_parameters.EndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
var start = DateTime.UtcNow;
while (true)
{
try
{
ListenSocket.Bind(_parameters.EndPoint);
break;
}
catch when(start + _parameters.RetrySocketBindingTime > DateTime.UtcNow)
{
}
Thread.Sleep(50);
}
ListenSocket.Listen(100);
var initialConnectionCount = _connectionAllocationStrategy.CalculateNewConnectionCount(0, 0);
AllocatedConnections = initialConnectionCount;
_blocks.Add(new ConnectionBlock(this, _layerFactory, initialConnectionCount));
}
public bool Start()
{
try
{
if (_stopThreads)
{
_stopThreads = false;
_thdWorker = new Thread(new ThreadStart(RemoveWorkerThreads));
_thdWorker.Start();
_listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// TODO: check if there is already a binding for the IPEndPoint
_listenSocket.Bind(new IPEndPoint(_address, _port));
_listenSocket.Listen(30);
_thdListener = new Thread(new ThreadStart(ListenerThread));
_thdListener.Start();
}
}
catch (Exception)
{
Stop();
return(false);
}
return(true);
}
public static void Main()
{
using (Socket listeningSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp))
{
listeningSocket.Bind(new IPEndPoint(IPAddress.Any, port));
Debug.Print("Listening for a client...");
listeningSocket.Listen(1);
using (Socket communicationSocket = listeningSocket.Accept())
{
Debug.Print("Connected to client.");
using (SslStream sslStream = new SslStream(communicationSocket))
{
X509Certificate serverCert =
new X509Certificate(Resources.GetBytes(Resources.BinaryResources.MyServer));
X509Certificate rootCA =
new X509Certificate(Resources.GetBytes(Resources.BinaryResources.MyRootCA));
sslStream.AuthenticateAsServer(serverCert, // To authenticate the server
new X509Certificate[] { rootCA }, // CA certificates
SslVerification.CertificateRequired, // Verify client
SslProtocols.Default // Protocols that may be used
);
//wait infinitely to get a response
sslStream.ReadTimeout = -1;
byte[] inBuffer = new byte[1000];
int count = sslStream.Read(inBuffer, 0, inBuffer.Length);
string message = new string(Encoding.UTF8.GetChars(inBuffer));
Debug.Print("Received '" + message + "'.");
}
}
}
}
public static ServerMock CreateTcp( int port, int bufferSize )
{
Socket socket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );
socket.Bind( new IPEndPoint( IPAddress.Loopback, port ) );
socket.Listen( 16 );
return new ServerMock( socket, bufferSize );
}
public static void StartServer()
{
IPAddress ip = IPAddress.Parse("127.0.0.1");
serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
serverSocket.Bind(new IPEndPoint(ip, myProt)); //绑定IP地址：端口
serverSocket.Listen(10); //设定最多10个排队连接请求
Console.WriteLine("启动监听{0}成功\n", serverSocket.LocalEndPoint.ToString());
while (true)
{
allDone.Reset();
serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), serverSocket);
allDone.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
//通过Clientsoket发送数据
//Thread myThread = new Thread(ListenClientConnect);
//myThread.Start();
Console.ReadLine();
}
public void server()
{
s.Bind(new IPEndPoint(IPAddress.Any, 12345));
s.Listen(1);
serverSocket = s.Accept();
}
void ListenThreadFunc()
{
Socket listenSocket = null;
try
{
listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ep = new IPEndPoint(IPAddress.Any, _port);
listenSocket.Bind(ep);
LogThread.Log("ListenThread: Listening on port " + _port, LogThread.LogMessageType.Normal, true);
while (true)
{
listenSocket.Listen(10);
Socket conn = listenSocket.Accept();
if (conn != null && OnConnectionAccepted != null)
{
LogThread.Log("ListenThread: Connection Accepted", LogThread.LogMessageType.Debug);
OnConnectionAccepted(this, new SocketArg(conn));
}
}
}
catch (Exception ex)
{
LogThread.Log(ex.ToString(), LogThread.LogMessageType.Error, true);
listenSocket.Close();
_theThread = null;
}
}
//private Thread _thThread;
/// <summary>
/// 开启TCP服务
/// </summary>
protected void StartTCP()
{
if (!_tcpEnabled && _running)
{
VerifyEndpointAddress(TcpEndPoint);
_tcpListen = new System.Net.Sockets.Socket(TcpEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
_tcpListen.Bind(TcpEndPoint);
}
catch (Exception ex)
{
Log.Error(string.Format("Could not bind to Address {0}: {1}", TcpEndPoint, ex));
Csl.Wl(string.Format("Could not bind to Address {0}: {1}", TcpEndPoint, ex));
return;
}
_tcpListen.Listen(CfgMgr.BasicCfg.MaxSimultaneousAcceptOps);
SocketHelpers.SetListenSocketOptions(_tcpListen);
_tcpEnabled = true;
StartAccept(null);
Log.Info(string.Format("Endpoint {0} start listening", TcpEndPoint));
}
}
/// <summary>
/// Запуск сервера
/// </summary>
public void Start()
{
try
{
if (_isListen)
{
Log.Logger.Information("Сокет сервер уже запущен");
return;
}
if (_serverEndPoint == null)
{
Log.Logger.Information("Не создан экземпляр сервера");
return;
}
_serverSocket.Bind(_serverEndPoint);
_serverSocket.Listen(100);
_isListen = true;
Log.Logger.Information("Ожидание новых подключений...");
_acceptConnectionsTokenSource = new CancellationTokenSource();
_acceptConnectionsToken = _acceptConnectionsTokenSource.Token;
_acceptConnections = Task.Run(AcceptConnectionsAsync, _acceptConnectionsToken);
}
catch (Exception ex)
{
Log.Logger.Information($"Произошла ошибка при включении сервера: {ex}");
}
}
private void SetUpServer(int countReintentos = 0)
{
try
{
if (ListenerSocker == null)
{
return;
}
ListenerSocker.Bind(new IPEndPoint(IPAddress.Any, port));
ListenerSocker.Listen(0x7FFFFFFF);
ListenerSocker.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
catch (Exception e)
{
Log.Log.GetLog().Error(this, "SetUpServer", e);
Thread.Sleep(5000);
if (countReintentos > 10)
{
Log.Log.GetLog().Info(this, "Fin Reintentos - SetUpServer - " + countReintentos);
return;
}
Log.Log.GetLog().Info(this, "Reintentando - SetUpServer - " + countReintentos);
SetUpServer(countReintentos + 1);
}
}
static List<Socket> klienciCzat = new List<Socket>(); //lista klientów - czyt. gniazd
static void Main(string[] args)
{
string adresIp = "192.168.1.163"; //podajemy adres ip naszezgo komputera na którym pracujemy trzeba go sprawdzic w cmd poprzez polecenie ipconfig następnie przepisać adres z ipv4 Address
//TODO: 1. Utworzenie punktu nadsłuchiwania - IPEndPoint
var punktNadsluchiwanie = new IPEndPoint(IPAddress.Parse(adresIp), 2000);
//TODO: 2. Utworzenie gniazda nadsłuchiwania - Socket
var gniazdo = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//TODO: 3. Przypisanie gniazda do adresu IP - Socket.Bind
gniazdo.Bind(punktNadsluchiwanie);
//TODO: 4. Rozpoczęcie nadsłuchiwania - Socket.Listen
gniazdo.Listen(10);
while (true)//TODO: 5. W pętli oczekiwanie na połączenia - Socket.Accept
{
var polaczenieZKlientem = gniazdo.Accept(); //oczekiwanie na połączenia
klienciCzat.Add(polaczenieZKlientem); //dodanie nowego klienta do listy
var danePolaczenie = string.Format("Port serwer: {0}; Klient: {1}:{2}",
((IPEndPoint)polaczenieZKlientem.LocalEndPoint).Port,
((IPEndPoint)polaczenieZKlientem.RemoteEndPoint).Address.ToString(),
((IPEndPoint)polaczenieZKlientem.RemoteEndPoint).Port);
Console.WriteLine(danePolaczenie);
var watek = new Thread(KlientCzat);
watek.IsBackground = true;
watek.Start(polaczenieZKlientem);
}
}
private void StartListening()
{
try
{
var listener = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listener.Bind(_iPEndPoint);
listener.Listen(200);
_isStart = true;
while (_isStart)
{
_acceptEvent.AcceptSocket = null;
_allDone.Reset();
var pending = listener.AcceptAsync(_acceptEvent);
if (!pending)
{
Accept_Completed(null, _acceptEvent);
}
_allDone.WaitOne();
}
}
catch (Exception.Exception ex)
{
throw ex;
}
}
/// <summary>
/// 启动监听
/// </summary>
/// <param name="config">服务器配置</param>
/// <returns></returns>
public override bool Start(IServerConfig config)
{
m_ListenSocket = new System.Net.Sockets.Socket(this.Info.EndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try
{
//关联终结地
m_ListenSocket.Bind(this.Info.EndPoint);
//设置监听最大连接数
m_ListenSocket.Listen(m_ListenBackLog);
m_ListenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
m_ListenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
//初始化套接字操作
SocketAsyncEventArgs acceptEventArg = new SocketAsyncEventArgs();
m_AcceptSAE = acceptEventArg;
//定义一个连接完成事件
acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(acceptEventArg_Completed);
if (!m_ListenSocket.AcceptAsync(acceptEventArg))
{
ProcessAccept(acceptEventArg);
}
return true;
}
catch (Exception e)
{
OnError(e);
return false;
}
}
//Main
static void Main(string[] args)
{
ILog log = LogManager.GetLogger(typeof(Program)); //Added
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
svrSkt = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
svrSkt.Bind(new IPEndPoint(IPAddress.Any, 2050));
svrSkt.Listen(0xff);
svrSkt.BeginAccept(Listen, null);
Console.CancelKeyPress += (sender, e) =>
{
Console.WriteLine("Saving Please Wait...");
svrSkt.Close();
foreach (var i in RealmManager.Clients.Values.ToArray())
{
i.Save();
i.Disconnect();
}
Console.WriteLine("\nClosing...");
Thread.Sleep(100);
Environment.Exit(0);
};
Console.ForegroundColor = ConsoleColor.Green;
Console.Title = "Server Engine";
Console.WriteLine("Accepting connections at port " + port + ".");
HostPolicyServer();
RealmManager.CoreTickLoop();
}
static void Main(string[] args)
{
// Default telnet port
int portNumber = 23;
// Command-line port (if any)
if (args.Length > 0 && args[0] != string.Empty)
{
int.TryParse(args[0], out portNumber);
}
// Server socket (Runs on the local machine using localhost)
Socket listeningSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listeningSocket.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), portNumber));
listeningSocket.Listen(portNumber);
// Server listens for a connection
while (true)
{
try
{
NewGame(listeningSocket.Accept());
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
private void StartListening()
{
_ListenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_ListenSocket.Bind(new IPEndPoint(IPAddress.Any, _ListenPort));
_ListenSocket.Listen(10);
_ListenSocket.BeginAccept(AcceptCallback, null);
}
/// <summary>
/// Creates an NeonMika.Webserver instance
/// </summary>
/// <param name="portNumber">The port to listen for incoming requests</param>
public Server(int portNumber = 80, bool DhcpEnable = true, string ipAddress = "", string subnetMask = "", string gatewayAddress = "")
{
var interf = NetworkInterface.GetAllNetworkInterfaces()[0];
if (DhcpEnable)
{
//Dynamic IP
interf.EnableDhcp();
//interf.RenewDhcpLease( );
}
else
{
//Static IP
interf.EnableStaticIP(ipAddress, subnetMask, gatewayAddress);
}
Debug.Print("Webserver is running on " + interf.IPAddress + " /// DHCP: " + interf.IsDhcpEnabled);
this._PortNumber = portNumber;
ResponseListInitialize();
_ListeningSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_ListeningSocket.Bind(new IPEndPoint(IPAddress.Any, portNumber));
_ListeningSocket.Listen(4);
}
public static string StartListen(string IPadress, string portStr)
{
try
{
IPAddress ipAddress = IPAddress.Parse(IPadress);
int port = System.Convert.ToInt32(portStr);
m_mainSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint ipLocal = new IPEndPoint(ipAddress, port); //(IPAddress.Any, port);
m_mainSocket.Bind(ipLocal);
m_mainSocket.Listen(4);
m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
isRunning = true;
return(ipLocal.ToString());
}
catch (SocketException se)
{
Console.WriteLine(se.Message);
return(null);
}
}
private void bomba1_DoWork(object sender, DoWorkEventArgs e)
{
Socket listener = new Socket(
AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp
);
String data = null;
listener.Bind(bomba1EndPoint);
listener.Listen(1);
// Create the state object.
sBomba1 = new StateObject();
sBomba1.bomba = bomba1;
sBomba1.workSocket = listener;
while (true)
{
listener.Accept();
bomba1Status.Text = "Bomba 1 conectada";
while (true)
{
int bytesRec = listener.Receive(sBomba1.buffer);
data += Encoding.ASCII.GetString(sBomba1.buffer, 0, bytesRec);
bomba1.ReportProgress(1, sBomba1);
}
}
}
public bool connect(string strIP, int portNum, int readTimeOut)
{
IPAddress[] ipAddr = Dns.GetHostAddresses(strIP);
IPAddress ip = ipAddr[0];
IPEndPoint hostEP = new IPEndPoint(ip, portNum);
isConnected = true;
try
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//初始化socket
s.Bind(hostEP);
s.Listen(0);
socket = s.Accept();
//尝试连接 客户端时
//socket=socket.Connect(hostEP);
}
catch (Exception se)
{
//MessageBox.Show("连接错误" + se.Message, "提示信息", MessageBoxButtons.RetryCancel, MessageBoxIcon.Information);
Console.WriteLine("连接错误" + se.Message);
isConnected = false;
return false;
}
ns = new NetworkStream(socket);
if (readTimeOut < 0)
readTimeOut = 0;
ns.ReadTimeout = readTimeOut;
return isConnected;
}
static void Main(string[] args)
{
var listener = new Socket(
AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
var ip = IPAddress.Parse("127.0.0.1");
var ep = new IPEndPoint(ip, 8000);
listener.Bind(ep);
listener.Listen(1);
for (; ; )
{
Console.WriteLine("接続待機中...");
Socket connection = listener.Accept();
// Accepted
Console.WriteLine("Accepted!!");
IPEndPoint remoteEP = (IPEndPoint)connection.RemoteEndPoint;
Console.WriteLine("Remote IP = {0}", remoteEP.Address);
Console.WriteLine("Remote Port = {0}", remoteEP.Port);
// Receive
byte[] receiveData = new byte[1000];
int size = connection.Receive(receiveData);
string receiveString = Encoding.UTF8.GetString(receiveData, 0, size);
Console.WriteLine("受信完了!");
Console.WriteLine("受信文字列 = {0}\n", receiveString);
}
}
public void ConnectMaster()
{
if (c_Connected && c_Server)
return;
try
{
c_Server = true;
//Console.WriteLine("CM Close Slave");
CloseSlave();
c_Master = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
c_Master.Bind(new IPEndPoint(IPAddress.Any, Data.MultiPort));
c_Master.Listen(4);
c_Master.BeginAccept(new AsyncCallback(OnClientConnect), null);
//Console.WriteLine("Started");
c_Connecting = false;
c_Connected = true;
}
catch (Exception /*e*/)// I HID e to stop warning message.
{
c_Server = false;
//Console.WriteLine(e.Message);
//Console.WriteLine(e.StackTrace);
}
}
private void Listen()
{
// 包含了一个IP地址
var ip = IPAddress.Parse("127.0.0.1");
// 包含了一对IP地址和端口号
var iep = new IPEndPoint(ip, 8500);
/*
* 创建一个Socket；
*
* 1.AddressFamily.InterNetWork：使用 IP4地址。
*
* 2.SocketType.Stream：支持可靠、双向、基于连接的字节流，
* 而不重复数据。此类型的 Socket 与单个对方主机进行通信，
* 并且在通信开始之前需要远程主机连接。
* Stream 使用传输控制协议 (Tcp) ProtocolType 和 InterNetworkAddressFamily。
*
* 3.ProtocolType.Tcp：使用传输控制协议。
*/
var socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// 绑定一个本地的IP和端口号（IPEndPoint），socket监听哪个端口
socket.Bind(iep);
// 定义byte数组存放从客户端接收过来的数据
var buffer = new byte[1024 * 1024];
// 同一个时间点过来10个客户端，排队
socket.Listen(10);
lblMsg.Text = string.Format("开始在{0}{1}上监听", iep.Address.ToString(), iep.Port.ToString());
System.Net.Sockets.Socket client;
int recv;
while (true)
{
// 接收连接并返回一个新的Socket
client = socket.Accept();
// 将接收过来的数据放到buffer中，并返回实际接受数据的长度
recv = client.Receive(buffer);
// 将字节转换成字符串
var cliMsg = Encoding.UTF8.GetString(buffer, 0, recv);
cliMsg = DateTime.Now.ToShortTimeString() + "," + client.RemoteEndPoint + "发来信息：" + cliMsg;
this.listBox1.Items.Add(cliMsg);
var serMsg = "服务器返回信息：OK.";
var serByte = Encoding.UTF8.GetBytes(serMsg);
// 输出数据到Socket
client.Send(serByte);
}
}
public void Listen()
{
serverSocket.Bind(new IPEndPoint(addr, _port));
serverSocket.Listen(10);
listenThread = new Thread(new ThreadStart(listenWorkThread));
listenThread.IsBackground = true;
listenThread.Start();
ServerStatus = ServerStatus.Runing;
}
public void start(IPEndPoint localEndPoint)
{
m_listenSocket = new System.Net.Sockets.Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
m_listenSocket.Bind(localEndPoint);
// start the server with a listen backlog of 100 connections
m_listenSocket.Listen(100);
start_accept(null);
//m_mutex.WaitOne();
}
/// <summary>
/// 开始服务器
/// </summary>
/// <param name="port">端口号</param>
/// <param name="count">连接队列总数（默认50）</param>
/// <param name="ip">ip地址（默认本机ip）</param>
public void StartServer(int port, int count = 50, string ip = "127.0.0.1")
{
socketWatch = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ipAdr = IPAddress.Parse(ip);
IPEndPoint iPEnd = new IPEndPoint(ipAdr, port);
try
{
socketWatch.Bind(iPEnd);
}
catch (Exception ex)
{
OnError?.Invoke($"Startup exception : {ex.ToString()}");
OnSuccess?.Invoke(false);
return;
}
socketWatch.Listen(count);
//开启心脏检测
Task.Run(() =>
{
while (true)
{
HearBeat();
Thread.Sleep(HeartbeatCheckInterval);
}
});
// 监听客户端请求的方法，线程
Task.Run(() =>
{
while (true)
{
System.Net.Sockets.Socket conn = socketWatch.Accept();
string socketip = conn.RemoteEndPoint.ToString();
conn.Send(SocketTools.GetBytes("YouIP," + socketip, IsOpenDesEnc));
Thread thr = new Thread(RecMsg);
thr.IsBackground = true;
thr.Start(conn);
string id;
AddSocketClient(socketip, conn, thr, out id);
OnClientAdd?.Invoke(this, new SocketArgs(new ClientInfo()
{
ip = socketip, id = id
}));
}
});
OnSuccess?.Invoke(true);
}
public Tcplinsten()
{
IPEndPoint localEP = new IPEndPoint(IPAddress.Any, 10086);
server = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server.Bind(localEP);
server.Listen(20);
new Thread(new ThreadStart(TcpListen)).Start();
}
static void Main(string[] args)
{
socket.Bind(new IPEndPoint(IPAddress.Any, 100));
socket.Listen(50);
Socket client = socket.Accept();
byte[] buffer = new byte[1024];
client.Receive(buffer);
}
/// <summary>
/// 服务端等待客户端接入
/// </summary>
static void ServerListen(ProgramData prog, System.Net.Sockets.Socket server)
{
try{
while (true)
{
server.Listen(10);
prog.watchating.Enqueue(server.Accept());
}
}catch (Exception e) { ExceptionClass.ExceptReporter(e); }
}
void IListenable.Bind(int Port)
{
m_Socket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
m_Socket.NoDelay = true;
m_Socket.Bind(new IPEndPoint(IPAddress.Any, Port));
m_Socket.Listen(backlog: 5);
m_Socket.BeginAccept(Accept, state: null);
}
void StartListeningSocket(IPAddress addr, int port)
{
socket = new System.Net.Sockets.Socket(addr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try {
socket.Bind(new IPEndPoint(addr, port));
socket.Listen(128);
socket.BeginAccept(AcceptCallback, null);
} catch {
}
}
public void Start(IPAddress address, int port)
{
Listener = new System.Net.Sockets.Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint = new IPEndPoint(address, port);
Listener.Bind(IPEndPoint);
Listener.Listen(100);
Listener.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
/// <summary>
/// 接收监听
/// </summary>
/// <returns></returns>
public Parm Receive(ServerInfo myConfig)
{
if (actLog == null)
{
actLog = (s) => { LogHelper.WriteInfo(s); }
}
;
//
var myParm = new Parm();
var myServerPoint = new IPEndPoint(IPAddress.Parse(myConfig.Ip), int.Parse(myConfig.Port));
myServerSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//1-监听
if (isDisplayLog)
{
actLog(string.Format("监听中...IP【{0}:{1}】", myServerPoint.Address, myServerPoint.Port));
}
myServerSocket.Bind(myServerPoint);
myServerSocket.Listen(10000);//允许监听的队列数
var mySocket = myServerSocket.Accept();
myParm.LocalEndPoint = mySocket.LocalEndPoint as IPEndPoint;
myParm.RemoteEndPoint = mySocket.RemoteEndPoint as IPEndPoint;
if (isDisplayLog)
{
actLog(string.Format("接入中...IP【{0}:{1}】", myParm.RemoteEndPoint.Address, myParm.RemoteEndPoint.Port));
}
//2-接收协议头：20个字节
var header = new byte[Common._Lenght_op + Common._Lenght_id + Common._Lenght_body];
int n = mySocket.Receive(header);
string str = Encoding.UTF8.GetString(header);
if (isDisplayLog)
{
actLog(string.Format("接收协议头...{0}", str));
}
//3-接收协议体：根据协议头里面给定的协议体长度接收
Parm.initHeader(myParm, str);
var length = myParm.data.Length;
if (length > 0)
{
n = mySocket.Receive(myParm.data);
if (isDisplayLog)
{
actLog(string.Format("接收数据体...长度{0}", length));
}
}
myServerSocket.Close();
return(myParm);
}
public static void Start_Server(IPEndPoint localEndPoint)
{
// Incoming data from the client
string data = null;
// Data buffer
byte[] bytes = new Byte[1024];
// Listen for incoming connections
try {
listener.Bind(localEndPoint);
listener.Listen(10);
while (true)
{
status_label.Text = "Waiting for a connection...";
System.Net.Sockets.Socket handler = listener.Accept();
data = null;
// Process incoming connection
while (true)
{
status_label.Text = "connected";
bytes = new byte[1024];
int bytesRec = handler.Receive(bytes);
data += Encoding.ASCII.GetString(bytes, 0, bytesRec);
// Show data in the console
console_text.Buffer.Text += data + "\n";
if (data.IndexOf("<EOF>") > -1)
{
handler.Shutdown(SocketShutdown.Both);
handler.Close();
status_label.Text = "disconnected";
break;
}
data = null;
}
// Send something back
byte[] msg = Encoding.ASCII.GetBytes("hello sir");
handler.Send(msg);
}
} catch (Exception e) {
console_text.Buffer.Text = e.ToString();
}
}
/// <summary>
/// Tcp测试用的服务器
/// </summary>
/// <param name="callback"></param>
/// <param name="port"></param>
public TcpTestsServer(Action <byte[]> callback, int port = 7777)
{
server = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var iep = new IPEndPoint(IPAddress.Any, port);
server.Bind(iep);
server.Listen(20);
this.callback = callback;
var tcpThread = new Thread(TcpListen);
tcpThread.Start();
}
