public async Task ThresholdExceeded_ThrowsException(string responseHeaders, int maxResponseHeadersLength, bool shouldSucceed)
{
using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
s.Bind(new IPEndPoint(IPAddress.Loopback, 0));
s.Listen(1);
var ep = (IPEndPoint)s.LocalEndPoint;
using (var handler = new HttpClientHandler() { MaxResponseHeadersLength = maxResponseHeadersLength })
using (var client = new HttpClient(handler))
{
Task<HttpResponseMessage> getAsync = client.GetAsync($"http://{ep.Address}:{ep.Port}", HttpCompletionOption.ResponseHeadersRead);
using (Socket server = s.Accept())
using (Stream serverStream = new NetworkStream(server, ownsSocket: false))
using (StreamReader reader = new StreamReader(serverStream, Encoding.ASCII))
{
string line;
while ((line = reader.ReadLine()) != null && !string.IsNullOrEmpty(line)) ;
byte[] headerData = Encoding.ASCII.GetBytes(responseHeaders);
serverStream.Write(headerData, 0, headerData.Length);
}
if (shouldSucceed)
{
(await getAsync).Dispose();
}
else
{
await Assert.ThrowsAsync<HttpRequestException>(() => getAsync);
}
}
}
}
//TODO Rewrite with networkStream. Read - Act - Write.
public void Listen()
{
string msg= "";
IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050);
Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
newsock.Bind(ipEndPoint);
newsock.Listen(10);
Socket client = newsock.Accept();
//IPEndPoint clientep = (IPEndPoint) client.RemoteEndPoint;
NetworkStream stream = new NetworkStream(client);
using (StreamReader streamReader = new StreamReader(stream))
{
while (streamReader.Peek() >= 0)
{
msg = string.Concat(msg, streamReader.Read());
}
}
ServerParser serverParser = new ServerParser();
string res = serverParser.Decode(msg);
using (StreamWriter streamWriter = new StreamWriter(stream))
{
streamWriter.WriteLine(res);
}
//http://www.java2s.com/Code/CSharp/Network/TcpClientSample.htm //TODO Remove links
//http://www.java2s.com/Code/CSharp/Network/SimpleTcpServer.htm
}
//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();
}
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);
}
}
private void ServerListen()
{
Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
serverSocket.Bind(new IPEndPoint(IPAddress.Any, localPort));
serverSocket.Listen(1);
while (true)
{
try
{
Socket clientSocket = serverSocket.Accept();
using (NetworkStream stream = new NetworkStream(clientSocket))
{
var request = ReadRequest(stream);
OnNewCmdReceived(request);
stream.Close();
}
clientSocket.Close();
}
catch (Exception ex)
{
Logger.AddError("Failed to process connection", ex);
}
}
}
/// <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();
}
}
static void Main(string[] args)
{
byte[] bytes = new Byte[1024];
// Establish the local endpoint for the socket.
// Dns.GetHostName returns the name of the
// host running the application.
string serverIP = args[0];// "192.168.56.1";
IPAddress ipAddress = IPAddress.Parse(serverIP);
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 1010);
// Create a TCP/IP socket.
Socket listener = new Socket(AddressFamily.InterNetwork,SocketType.Stream, ProtocolType.Tcp);
Console.WriteLine("This is a Server ");
// Bind the socket to the local endpoint and
// listen for incoming connections.
try
{
listener.Bind(localEndPoint);
listener.Listen(10);
// Start listening for connections.
while (true)
{
Console.WriteLine("Server: Waiting for a connection...");
// Program is suspended while waiting for an incoming connection.
Socket handler = listener.Accept();
string data = null;
// An incoming connection needs to be processed.
bytes = new byte[1024];
while (true)
{
int bytesRec = handler.Receive(bytes);
data = Encoding.ASCII.GetString(bytes, 0, bytesRec);
if (data.IndexOf("<EOF>") > -1)
{
Console.WriteLine("Client is done sending all the text");
break;
}
if (bytesRec == 0)
{
continue;
}
else
{
Console.WriteLine("Text received from client: " + data);
bytesRec = 0;
data = "";
}
}
handler.Shutdown(SocketShutdown.Both);
handler.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
Console.Read();
}
public static void Main()
{
while (true)
{
var networkInterface = NetworkInterface.GetAllNetworkInterfaces()[0];
Debug.Print(networkInterface.IPAddress.ToString());
networkInterface.EnableStaticIP("192.168.1.200", "255.255.255.0", "192.168.1.1");
using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
socket.Bind(new IPEndPoint(IPAddress.Any, 5230));
socket.Listen(1);
while (true)
{
using (client = socket.Accept())
{
clientActive = true;
while (clientActive)
{
var buffer = new byte[5];
client.Receive(buffer);
InterpretCommand(buffer);
}
}
}
}
}
}
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();
}
private void ListenerThread()
{
while (!_stopThreads)
{
Socket client = null;
try
{
client = _listenSocket.Accept();
}
catch (Exception)
{
break;
}
if (client == null)
{
continue;
}
if (!OnClientConnected((client.RemoteEndPoint as IPEndPoint).Address))
{
client.Close();
continue;
}
CreateWorkerProcess(client);
}
}
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();
}
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);
}
}
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);
}
}
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();
}
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;
}
}
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;
}
public void FTPSessionThread()
{
while (true)
{
try
{
clientSocket = serverSocket.Accept();
// Socket Information
IPEndPoint clientInfo = (IPEndPoint)clientSocket.RemoteEndPoint;
IPEndPoint serverInfo = (IPEndPoint)serverSocket.LocalEndPoint;
Console.WriteLine("Client: " + clientInfo.Address.ToString() + ":" + clientInfo.Port.ToString());
Console.WriteLine("Server: " + serverInfo.Address.ToString() + ":" + serverInfo.Port.ToString());
// Set Thread for each FTP client Connection
Thread clientThread = new Thread(new ThreadStart(this.ProcessRequest));
clientThread.Start();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace.ToString());
if (clientSocket.Connected)
{
clientSocket.Close();
}
}
}
}
/// <summary>
/// 启动等待连接
/// </summary>
public void StartConnection()
{
serverListener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP); // Start the socket
string[] ip = WebSocketProtocol.GetInstance.ServerId.Split('.');
IPAddress localIp = new IPAddress(new byte[] { Convert.ToByte(ip[0]), Convert.ToByte(ip[1]), Convert.ToByte(ip[2]), Convert.ToByte(ip[3]) });
serverListener.Bind(new IPEndPoint(localIp, WebSocketProtocol.GetInstance.ServerPort));
serverListener.Listen(WebSocketProtocol.GetInstance.ConnectionsCount);
while (true)
{
//等待客户端请求
Socket sc = serverListener.Accept();
if (sc != null)
{
Thread.Sleep(100);
ClientSocketInstance ci = new ClientSocketInstance();
ci.ClientSocket = sc;
//初始化三个事件
ci.NewUserConnection += new ClientSocketEvent(Ci_NewUserConnection);
ci.ReceiveData += new ClientSocketEvent(Ci_ReceiveData);
ci.DisConnection += new ClientSocketEvent(Ci_DisConnection);
//开始与客户端握手[握手成功，即可通讯了]
ci.ClientSocket.BeginReceive(ci.receivedDataBuffer, 0, ci.receivedDataBuffer.Length, 0, new AsyncCallback(ci.StartHandshake), ci.ClientSocket.Available);
listConnection.Add(ci);
}
}
}
static void Main(string[] args)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint address = new IPEndPoint(IPAddress.Any, 8080);
socket.Bind(address);
socket.Listen(10);
//int i = 0;
//int N = 2;
//Socket[] clients = new Socket[N];
while (true)
{
Socket client = socket.Accept();
String template = "HTTP/1.1 200 OK\r\n" +
"Server: NataServer\r\n" +
"Content-Type: text/plain; charset=UTF-8\r\n" +
"Content-Length: {0}\r\n" +
"\r\n" +
"{1}";
String s = DateTime.Now.ToString();
String answer = String.Format(template, s.Length, s);
Console.WriteLine(answer);
byte[] msg = Encoding.UTF8.GetBytes(answer);
client.Send(msg);
client.Shutdown(SocketShutdown.Both);
client.Close();
}
}
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);
}
}
}
static void Main(string[] args)
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
IPAddress ip = IPAddress.Parse("127.0.0.1");
IPEndPoint ep = new IPEndPoint(ip, 1024);
s.Bind(ep);
s.Listen(10);
try
{
while (true)
{
Socket ns = s.Accept();
Console.WriteLine(ns.RemoteEndPoint.ToString());
ns.Send(System.Text.Encoding.ASCII.GetBytes(DateTime.Now.ToString()));
ns.Shutdown(SocketShutdown.Both);
ns.Close();
}
}
catch (SocketException ex)
{
Console.WriteLine(ex.Message);
}
}
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);
}
}
static void Main()
{
// I'm going to listen for any incoming requests on this machine so I need to find out
// what my address is. An empty string tells it to get the address of this machine
var ipAddr = Dns.GetHostAddresses("")[0];
// create a server socket, its only purpose is to listen for connections
// and to create client sockets to handle requests
// going to use TCP to communicate
var server = new Socket(ipAddr.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
// the server will be located on port 4510 on this machine
server.Bind(new IPEndPoint(ipAddr, 4510));
// start listening and allow for a backlog of 10 request between our accepts
server.Listen(10);
Console.WriteLine("Waiting to get asked the time");
while (true)
{
// Wait for a client to connect, Accept is blocking
// request is a client socket and will be used for this piece of communication
var client = server.Accept();
Console.WriteLine("Connection accepted");
Task.Factory.StartNew(() => Chat(client));
}
}
//-------------------------------------------------------------------------------------------
public void Listen(string ipaddress, int port)
{
IPEndPoint ipendpoint = new IPEndPoint(IPAddress.Parse(ipaddress), port);
Socket Listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listenersocket = Listener;
try
{
Listener.Bind(ipendpoint);
Listener.Listen((int) SocketOptionName.MaxConnections);
DebugOut("Listening on: " + Listener.LocalEndPoint.ToString(), false);
}
catch(Exception e)
{
DebugOut("Failed to bind: " + e.Message, true);
return;
}
while (!Listening && !Environment.HasShutdownStarted)
{
try
{
ThreadPool.QueueUserWorkItem(_OnAccept, Listener.Accept());
}
catch
{
Thread.Sleep(100);
}
}
Listener.Shutdown(SocketShutdown.Both);
Listener.Close();
}
public Signaler()
{
m_dummy = new byte[] { 0 };
m_receiveDummy = new byte[1];
// Create the socketpair for signaling.
using (var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Unspecified))
{
listener.NoDelay = true;
listener.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
// using ephemeral port
listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
listener.Listen(1);
m_writeSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Unspecified);
m_writeSocket.NoDelay = true;
m_writeSocket.Connect(listener.LocalEndPoint);
m_readSocket = listener.Accept();
}
m_writeSocket.Blocking = false;
m_readSocket.Blocking = false;
}
public void StartListening(int port)
{
var ipAddress = IPAddress.Parse("0.0.0.0");
var localEndPoint = new IPEndPoint(ipAddress, port);
var listener = new Socket(ipAddress.AddressFamily,
SocketType.Stream, ProtocolType.Tcp);
try
{
listener.Bind(localEndPoint);
listener.Listen(20);
while (true)
{
var handler = listener.Accept();
var callback = new ThreadPoolCallback(handler);
ThreadPool.QueueUserWorkItem(callback.Execute);
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public static void Main()
{
var networkInterface = NetworkInterface.GetAllNetworkInterfaces()[0];
Debug.Print(networkInterface.IPAddress.ToString());
//networkInterface.IsDynamicDnsEnabled = false;
//
networkInterface.EnableStaticIP("192.168.1.200", "255.255.255.0", "192.168.1.1");
using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
socket.Bind(new IPEndPoint(IPAddress.Any, 5230));
socket.Listen(1);
while (true)
{
using (var client = socket.Accept())
{
//new Thread(() =>
//{
var clientActive = true;
while (clientActive)
{
//var buffer = new byte[5];
//client.Receive(buffer);
var buffer = client.Receive(5);
Interpret(buffer, client);
}
//}).Start();
}
}
}
}
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 StartSever()
{
try
{
ipEnd = new IPEndPoint(IPAddress.Parse(config.configMaquina.IP), Convert.ToInt32(config.configMaquina.Porta));
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
socket.Bind(ipEnd);
socket.Listen(Convert.ToInt32(config.configMaquina.Porta));
while (true)
{
try
{
Socket clientSock = socket.Accept();
HandleTransferClient client = new HandleTransferClient(clientSock);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
catch (Exception e)
{
Utils.Logger.getInstance.error(e.ToString());
}
}
static void Main(string[] args)
{
Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint ie = new IPEndPoint(IPAddress.Any, 9000);
s.Bind(ie);
s.Listen(10);
Console.WriteLine("Waiting data from Client....");
Socket sc = s.Accept();
byte[] data = new byte[1024];
data = Encoding.ASCII.GetBytes("Chao Client");
sc.Send(data, data.Length, SocketFlags.None);
while (true)
{
string st;
byte[] dl = new byte[1024];
int k = sc.Receive(dl);
st = Encoding.ASCII.GetString(dl, 0, k);
if (st.ToUpper().Equals("QUIT"))
break;
Console.WriteLine("Du lieu tu Client:{0}", st);
st = st.ToUpper();
dl = new byte[1024];
dl = Encoding.ASCII.GetBytes(st);
sc.Send(dl, dl.Length, SocketFlags.None);
}
sc.Close();
s.Close();
}
public JTAGSerialStream2(string Cable, int Device, int Instance)
{
try
{
Socket SerialListenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint SerialEP = new IPEndPoint(IPAddress.Any, 0);
SerialListenSocket.Bind(SerialEP);
SerialListenSocket.Listen(1);
SerialEP = (IPEndPoint)SerialListenSocket.LocalEndPoint;
SerialProcess = new Process();
SerialProcess.StartInfo.FileName = "quartus_stp";
SerialProcess.StartInfo.Arguments = String.Format("-t serial.tcl \"{0}\" {1} {2} {3}", Cable, Device, Instance, SerialEP.Port);
SerialProcess.EnableRaisingEvents = true;
SerialProcess.Exited +=
delegate(object Sender, EventArgs e)
{
if (SerialListenSocket != null)
SerialListenSocket.Close();
};
SerialProcess.Start();
SerialSocket = SerialListenSocket.Accept();
SerialListenSocket.Close();
SerialListenSocket = null;
}
catch (System.ComponentModel.Win32Exception e)
{
throw new JTAGException(String.Format("Error starting JTAG serial process: {0}", e.Message));
}
}
public void server()
{
s.Bind(new IPEndPoint(IPAddress.Any, 12345));
s.Listen(1);
serverSocket = s.Accept();
}
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();
}
static void Main(string[] args)
{
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 21344);
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server.Bind(ipep);
server.Listen(10);
Socket client = server.Accept();
NetworkStream ns = new NetworkStream(client, true);
DataSocketWriter dsw = new DataSocketWriter(ns);
List<Value> list_values = new List<Value>();
list_values.Add(Value.Create("A string value"));
list_values.Add(Value.Create(1234));
list_values.Add(Value.Create(4321.001));
ValueVector val_vector = new ValueVector { values = list_values.ToArray() };
dsw.Send(val_vector);
while(true)
{
// server needs to halt here, else process exit and things are not sent
Thread.Sleep(0);
}
}
public void FTPSessionThread()
{
while (true)
{
try
{
// 處理用戶端連線
clientSocket = serverSocket.Accept();
// 取得本機相關的網路資訊
IPEndPoint serverInfo = (IPEndPoint)serverSocket.LocalEndPoint;
// 取得連線用戶端相關的網路連線資訊
IPEndPoint clientInfo = (IPEndPoint)clientSocket.RemoteEndPoint;
Console.WriteLine("Server: " + serverInfo.Address.ToString() + ":" + serverInfo.Port.ToString());
Console.WriteLine("Client: " + clientInfo.Address.ToString() + ":" + clientInfo.Port.ToString());
// 執行緒
Thread clientThread = new Thread(new ThreadStart(this.processRequest));
clientThread.Start();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace.ToString());
if (clientSocket.Connected)
{
clientSocket.Close();
}
}
}
}
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 + "'.");
}
}
}
}
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);
}
}
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>
/// <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 void ServerThreadProc()
{
while (true)
{
try
{
// 處理用戶端連線
clientSocket = serverSocket.Accept();
// 取得本機相關的網路資訊
IPEndPoint serverInfo = (IPEndPoint)serverSocket.LocalEndPoint;
// 取得連線用戶端相關的網路連線資訊
IPEndPoint clientInfo = (IPEndPoint)clientSocket.RemoteEndPoint;
Console.WriteLine("Server: " + serverInfo.Address.ToString() + ":" + serverInfo.Port.ToString());
Console.WriteLine("Client: " + clientInfo.Address.ToString() + ":" + clientInfo.Port.ToString());
// 設定接收資料緩衝區
byte[] bytes = new Byte[1024];
// 自已連線的用戶端接收資料
int bytesReceived = clientSocket.Receive(bytes, 0, bytes.Length, SocketFlags.None);
if (bytesReceived > 0)
{
Console.WriteLine("接收位元組數目: {0}", bytesReceived);
Console.WriteLine("接收的資料內容: \r\n" + "{0}", Encoding.UTF8.GetString(bytes, 0, bytesReceived) + "\r\n");
}
// 測試用
string htmlBody = "<html><head><title>Send Test</title></head><body><font size=2 face=Verdana>Sent OK.</font></body></html>";
string htmlHeader = "HTTP/1.0 200 OK" + "\r\n" + "Server: HTTP Server 1.0" + "\r\n" + "Content-Type: text/html" + "\r\n" + "Content-Length: " + htmlBody.Length + "\r\n\r\n";
string htmlContent = htmlHeader + htmlBody;
// 設定傳送資料緩衝區
byte[] msg = Encoding.ASCII.GetBytes(htmlContent);
// 傳送資料至已連線的用戶端
int bytesSend = clientSocket.Send(msg, 0, msg.Length, SocketFlags.None);
Console.WriteLine("傳送位元組數目: {0}", bytesSend);
Console.WriteLine("傳送的資料內容: " + "\r\n" + "{0}", Encoding.UTF8.GetString(msg, 0, bytesSend) + "\r\n");
// 同時暫停用戶端的傳送和接收作業
clientSocket.Shutdown(SocketShutdown.Both);
// 關閉用戶端Socket
clientSocket.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace.ToString());
}
}
}
/// <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); }
}
/// <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();
}
}
protected override Socket DoAccept()
{
while (true)
{
if (Select(mSocket, 250))
{
Socket s = new SocketTCP(mSocket.Accept());
return(s);
}
}
}
/// <summary>
/// Function : Tcp Connect Set Server Up
/// </summary>
/// <returns></returns>
public FunctionResult TcpConnectServerSetUp()
{
try
{
TcpConnectServerSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
catch (SocketException)
{
// log information
FFTAICommunicationManager.Instance.Logger.WriteLine("SocketException", true);
return(FunctionResult.SocketException);
}
try
{
TcpConnectServerSocket.Bind(TcpConnectServerEndPoint);
}
catch (ArgumentNullException)
{
// log information
FFTAICommunicationManager.Instance.Logger.WriteLine("ArgumentNullException", true);
return(FunctionResult.ArgumentNullException);
}
catch (SocketException)
{
// log information
FFTAICommunicationManager.Instance.Logger.WriteLine("SocketException", true);
return(FunctionResult.SocketException);
}
catch (ObjectDisposedException)
{
// log information
FFTAICommunicationManager.Instance.Logger.WriteLine("ObjectDisposedException", true);
return(FunctionResult.ObjectDisposedException);
}
catch (SecurityException)
{
// log information
FFTAICommunicationManager.Instance.Logger.WriteLine("SecurityException", true);
return(FunctionResult.SecurityException);
}
TcpConnectServerSocket.Listen(10);
System.Net.Sockets.Socket socket = TcpConnectServerSocket.Accept(); // 阻断程序
return(FunctionResult.Success);
}
/// <summary>
/// 获取客户端请求
/// </summary>
private void getSocket()
{
System.Net.Sockets.Socket listenSocket = socket;
SocketLink newSocketLink, head;
while (socket != null)
{
try
{
NEXT:
newSocketLink = new SocketLink();
newSocketLink.Socket = listenSocket.Accept();
if (socket == null)
{
return;
}
do
{
if ((head = socketHead) == null)
{
newSocketLink.LinkNext = null;
if (Interlocked.CompareExchange(ref socketHead, newSocketLink, null) == null)
{
socketHandle.Set();
newSocketLink = null;
goto NEXT;
}
}
else
{
newSocketLink.LinkNext = head;
if (Interlocked.CompareExchange(ref socketHead, newSocketLink, head) == head)
{
newSocketLink = null;
goto NEXT;
}
}
AutoCSer.Threading.ThreadYield.YieldOnly();
}while (true);
}
catch (Exception error)
{
if (socket == null)
{
break;
}
RegisterServer.TcpServer.Log.Add(AutoCSer.Log.LogType.Error, error);
Thread.Sleep(1);
}
}
}
private void TcpListen()
{
while (!exitFlag)
{
try
{
var client = server.Accept();
var newClient = new ClientThread(client, callback);
var newThread = new Thread(newClient.ClientService);
newThread.Start();
}
catch { }
}
}
/// <summary>
/// 循环监听
/// </summary>
void listen()
{
Socket sockets;
byte[] data;
try
{
sockets = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sockets.Bind(localIpe);
}
catch { return; }
while (true)
{
try
{
sockets.Listen(200);
Socket newSocket = sockets.Accept();
using (MemoryStream ms = new MemoryStream())
{
byte[] btMsg = new byte[10240];
int t = 1;
while (t > 0)
{
t = newSocket.Receive(btMsg);
ms.Write(btMsg, 0, t);
}
data = ms.ToArray();
}
newSocket.Close();
NetOrder no = new NetOrder(data);
no.Root = Root;
no.LocalIPE = localIpe;
new NetOrderDealer(no).Run();
if (RecievedOrder != null)
{
RecievedOrder(this, no);
}
Thread.Sleep(1);
}
catch (SocketException ex) { Console.WriteLine(ex.Message); }
}
}
private void listenWorkThread()
{
while (controller)
{
try
{
Socket client = serverSocket.Accept();
ThreadPool.QueueUserWorkItem((obj) =>
{
clientWorkThread(client);
});
}
catch { }
}
}
public string ReceiveData()
{
System.Net.Sockets.Socket receiveSocket;
byte[] buffer = new byte[256];
receiveSocket = serverSocket.Accept();
var bytesrecd = receiveSocket.Receive(buffer);
receiveSocket.Close();
System.Text.Encoding encoding = System.Text.Encoding.UTF8;
return(encoding.GetString(buffer));
}
/// <summary>
/// Start accepting socket connections.
/// </summary>
private void StartAccept()
{
try
{
// Clear last error.
ClearLastError();
do
{
// Set the event to nonsignaled state.
_connAvailable.Reset();
// Do not allow any more clients
// if maximum is reached.
if (_clientCount < _maxNumClients)
{
System.Net.Sockets.Socket clientSocket = null;
// Create a new client connection handler for the current
// tcp client attempting to connect to the server. Creates
// a new channel from the client to the server.
clientSocket = _socket.Accept();
// Create the client state.
CreateServerContext(clientSocket);
Thread.Sleep(20);
}
else
{
// Blocks the current thread until a
// connection becomes available.
_connAvailable.WaitOne();
}
} while (true);
}
catch (Exception ex)
{
// Stop listening.
StopListening();
SetLastError(ex);
// Trigger the stop listening event.
StopListeningEvent(ex);
}
}
public void ServerThreadProc()
{
while (true)
{
try
{
// 處理用戶端連線
clientSocket = serverSocket.Accept();
// 取得本機相關的網路資訊
IPEndPoint serverInfo = (IPEndPoint)clientSocket.LocalEndPoint;
// 取得連結用戶端相關的網路連接資訊
IPEndPoint clientInfo = (IPEndPoint)clientSocket.RemoteEndPoint;
Console.WriteLine("Server: " + serverInfo.Address.ToString() + ":" + serverInfo.Port.ToString());
Console.WriteLine("Client: " + clientInfo.Address.ToString() + ":" + clientInfo.Port.ToString());
}
catch (Exception ex) { }
}
}
private static void Accept(IntPtr info)
{
NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info);
SOCKET socket = GetSocket(arguments.This);
if (socket == null || SocketExtension.CleanedUp(socket))
{
Throwable.ObjectDisposedException(arguments.VirtualMachine);
}
else
{
try
{
arguments.SetReturnValue(New(arguments.VirtualMachine, socket.Accept()));
}
catch (Exception e)
{
Throwable.Exception(arguments.VirtualMachine, e);
}
}
}
public static void Main()
{
const Int32 c_port = 12000;
// Create a socket, bind it to the server's port, and listen for client
// connections.
Socket server = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Any, c_port);
server.Bind(localEndPoint);
server.Listen(Int32.MaxValue);
while (true)
{
// Wait for a client to connect.
Socket clientSocket = server.Accept();
// Process the client request. true means asynchronous.
new ProcessClientRequest(clientSocket, true);
}
}
private void startListening()
{
byte[] data = new byte[BUFFER_SIZE];
_listener.Listen(10);
while (true)
{
var clientSocket = _listener.Accept();
int bytesRecieve = clientSocket.Receive(data);
if (bytesRecieve > 0)
{
byte[] tempData = new byte[2048];
while (!isFullData(bytesRecieve, data))
{
bytesRecieve += clientSocket.Receive(tempData);
data.ToList().AddRange(tempData);
}
;
var sslMessage = SslSerialization.BytesToObject <SslMessage>(data.Skip(4).ToArray());
var sender = new Sender(sslMessage.PortForReplaying, clientSocket, this);
clientSocket.Shutdown(NetSockets.SocketShutdown.Both);
clientSocket.Close();
if (sslMessage.CallbackFunction != null && _controller != null)
{
SslInvoker.InvokeFunction(_controller, sslMessage.CallbackFunction, new object[] { sender, sslMessage.Data });
}
data = new byte[BUFFER_SIZE];
// OnRecieveEvent(sender, sslMessage.Data);
}
}
}
public void ServerThreadProc()
{
while (true)
{
try
{
// 處理用戶端連線
clientSocket = serverSocket.Accept();
// 取得本機相關的網路資訊
IPEndPoint serverInfo = (IPEndPoint)serverSocket.LocalEndPoint;
// 取得連線用戶端相關的網路連線資訊
IPEndPoint clientInfo = (IPEndPoint)clientSocket.RemoteEndPoint;
Console.WriteLine("Server: " + serverInfo.Address.ToString() + ":" + serverInfo.Port.ToString());
Console.WriteLine("Client: " + clientInfo.Address.ToString() + ":" + clientInfo.Port.ToString());
// 設定接收資料緩衝區
byte[] bytes = new Byte[1024];
// 自已連線的用戶端接收資料
int bytesReceived = clientSocket.Receive(bytes, 0, bytes.Length, SocketFlags.None);
if (bytesReceived > 0)
{
Console.WriteLine("接收位元組數目: {0}", bytesReceived);
Console.WriteLine("接收的資料內容: \r\n" + "{0}", Encoding.UTF8.GetString(bytes, 0, bytesReceived) + "\r\n");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.StackTrace.ToString());
}
}
}
/// <summary>
///
/// </summary>
/// <param name="serverIP"></param>
/// <param name="clientIP"></param>
/// <param name="port"></param>
public Server(IPAddress serverIP, IPAddress clientIP, int port)
{
debug("Starting server...\n");
this.serverIP = serverIP;
this.clientIP = clientIP;
this.port = port;
this.serverEndPoint = new IPEndPoint(this.serverIP, this.port);
this.clientEndPoint = new IPEndPoint(this.clientIP, this.port);
this.serverSocket = new System.Net.Sockets.Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP);
this.serverSocket.Bind(serverEndPoint);
this.serverSocket.Listen(0);
debug("Waiting for client...\n");
this.clientSocket = serverSocket.Accept();
debug("Client connected...\n");
//add();
//echo();
}
Utils.Wrappers.Interfaces.ISocket Utils.Wrappers.Interfaces.ISocket.Accept()
{
return(new SocketWrapped(InternalSocket.Accept()));
}
public ISocket Accept()
{
var socket = _socket.Accept();
return(new Socket(socket));
}
/// <summary>
/// Processes incoming requests
/// </summary>
protected void ProcessRequest()
{
// accept an incoming connection request and once we have one, spawn a new thread to accept more
bool newThread = false;
System.Net.Sockets.Socket clientSocket = null;
Responder responder = null;
while (IsRunning && !newThread)
{
try
{
// process incoming request
clientSocket = LocalServer.Accept();
clientSocket.ReceiveTimeout = Timeout;
clientSocket.SendTimeout = Timeout;
// parse message an create an object containing parsed data
responder = new Responder();
responder.ClientEndpoint = clientSocket.RemoteEndPoint.ToString();
responder.ClientSocket = clientSocket;
Thread t = new Thread(new ThreadStart(ProcessRequest));
t.Start();
newThread = true;
}
catch
{
if (clientSocket != null)
{
try
{
clientSocket.Close();
}
catch { }
}
}
}
// now process the request
try
{
bool finishedParsing = false;
TimeSpan parseStart = Timer.GetMachineTime();
while (!finishedParsing)
{
if (Timer.GetMachineTime() - parseStart > MaxProcessingTime)
{
return;
}
// receiving data, add to an array to process later
byte[] buffer = new byte[clientSocket.Available];
clientSocket.Receive(buffer);
finishedParsing = responder.parse(buffer);
}
// trigger event to get response
WebEvent webevent = null;
if (responder.Path != null && responder.Path.Length > 1)
{
webevent = serverManager.GetWebEventById(responder.Path);
}
if (webevent == null)
{
webevent = serverManager.DefaultEvent;
}
responder.webEvent = webevent;
webevent.OnWebEventReceived(responder.Path, responder.HttpMethod, responder);
}
catch
{
}
}
