I'm connecting to my server on the internal network. But I cannot connect to a server on an external network. The server's firewall on the external network closed. The port forwarding server was.
Server side codes:
private byte[] _buffer = new byte[1024];
private List<Socket> _clientSockets = new List<Socket>();
private Socket _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
public int PortNo;
private void SetupServer()
{
try
{
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, PortNo));
_serverSocket.Listen(1);
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallBack), null);
}
catch(Exception hata)
{
MessageBox.Show(hata.Message);
}
}
private void AcceptCallBack(IAsyncResult AR)
{
Socket socket = _serverSocket.EndAccept(AR);
_clientSockets.Add(socket);
try
{
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), socket);
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallBack), null);
}
catch(Exception hata)
{
MessageBox.Show(hata.Message);
}
}
private void ReceiveCallBack(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
int received = socket.EndReceive(AR);
byte[] dataBuf = new byte[received];
Array.Copy(_buffer, dataBuf, received);
string text = Encoding.ASCII.GetString(dataBuf);
byte[] response = response = ekranGonderme();
try
{
socket.BeginSend(response, 0, response.Length, SocketFlags.None, new AsyncCallback(SendCallBack), null);
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), socket);
}
catch(Exception hata)
{
MessageBox.Show(hata.Message);
}
}
Client Side Codes:
private static Socket _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
int portNo = 20000;
IPAddress[] server_ip = Dns.GetHostAddresses(server's external ip address);
private void Form1_Load(object sender, EventArgs e)
{
LoopConnect();
LoopSendReceive()
}
private void LoopSendReceive()
{
try
{
byte[] buffer = Encoding.ASCII.GetBytes("ekran_iste");
_clientSocket.Send(buffer);
byte[] receiveBuf = new byte[999999];
int rec = _clientSocket.Receive(receiveBuf);
byte[] data = new byte[rec];
Array.Copy(receiveBuf, data, rec);
MemoryStream ms = new MemoryStream(data);
}
catch
{
}
}
private void LoopConnect()
{
int attempts = 0;
while (!_clientSocket.Connected)
{
try
{
attempts++;
_clientSocket.Connect(server_ip[0], portNo);
}
catch(SocketException)
{
}
}
}
}
Related
I am trying to create a program where a server communicates to clients and give them commands about what to do. But when I connect multiple clients it sends the commands to the client multiple random times. My current code:
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
namespace Server
{
class Program
{
private static byte[] _buffer = new byte[1024];
private static List<Socket> _clientSockets = new List<Socket>();
private static int SERVERPORT = 5555;
private static Socket _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
private static String command;
static void Main(string[] args)
{
Thread serverThread = new Thread(new ThreadStart(SetupServer));
Thread readThread = new Thread(new ThreadStart(checkInput));
serverThread.Start();
readThread.Start();
}
private static void SetupServer()
{
Console.WriteLine("Setting up server...");
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, SERVERPORT));
_serverSocket.Listen(100);
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
private static void AcceptCallback(IAsyncResult AR)
{
while (true)
{
if (_serverSocket != null)
{
try
{
Socket socket = _serverSocket.EndAccept(AR);
_clientSockets.Add(socket);
Console.WriteLine("Client conntected");
}
catch
{
}
}
if (command != null)
{
byte[] data = Encoding.ASCII.GetBytes(command);
foreach (Socket s in _clientSockets)
{
s.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), s);
}
}
command = null;
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
}
}
private static void ReceiveCallback(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
//int received = socket.EndReceive(AR);
//byte[] dataBuf = new byte[received];
//Array.Copy(_buffer, dataBuf, received);
//string text = Encoding.ASCII.GetString(dataBuf);
string response = string.Empty;
response = Console.ReadLine();
byte[] data = Encoding.ASCII.GetBytes(response);
socket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), socket);
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), socket);
}
private static void SendCallback(IAsyncResult AR)
{
try {
Socket socket = (Socket)AR.AsyncState;
socket.EndSend(AR);
}
catch {
}
}
public static void checkInput()
{
while (true)
{
command = Console.ReadLine();
}
}
}
}
An example. I start the server and start 3 clients next. This is the output:
I am totally clueless why it sends random times. Also why is there a double 2 on console #2. Thanks in advance!
This caused the problem:
if (command != null)
{
byte[] data = Encoding.ASCII.GetBytes(command);
foreach (Socket s in _clientSockets)
{
s.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), s);
}
}
command = null;
I added this piece of code to the readThread thread.
public static void checkInput()
{
while (true)
{
command = Console.ReadLine();
Console.WriteLine("Sending");
byte[] data = Encoding.ASCII.GetBytes(command);
foreach (Socket s in _clientSockets)
{
s.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), s);
}
command = null;
}
}
this solved it.
I want to write a programm where multiple clients can join on a server. For now the clients are only able to ask for the servertime, which works perfectly fine, as long as the client and the server are on the same pc. I'm pretty sure that I have to change the EndPoint in the Connect() Method of the client, but I don't know what i should change it to.
Please help me to find a solution for this.
I have this code on my server:
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
namespace Multiple_Clients
{
class Program
{
private static int port = 4567;
private static byte[] _buffer = new byte[1024];
private static List<Socket> _clientSockets = new List<Socket>();
private static Socket _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
static void Main(string[] args)
{
Console.Title = "Server";
setupServer();
Console.ReadLine();
}
private static void setupServer()
{
Console.WriteLine("Setting up server...");
_serverSocket.Bind(new IPEndPoint(IPAddress.Any, port));
_serverSocket.Listen(500);
_serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);
}
private static void acceptCallback(IAsyncResult AR)
{
Socket socket = _serverSocket.EndAccept(AR);
_clientSockets.Add(socket);
Console.WriteLine("Client connected");
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
_serverSocket.BeginAccept(new AsyncCallback(acceptCallback), null);
}
private static void receiveCallback(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
int received = socket.EndReceive(AR);
byte[] dataBuf = new byte[received];
Array.Copy(_buffer, dataBuf, received);
string text = Encoding.ASCII.GetString(dataBuf);
Console.WriteLine("Text received: " + text);
string response = string.Empty;
if (text.ToLower() != "get time")
{
response = "Invalid Request";
}
else
{
response = DateTime.Now.ToLongTimeString();
}
byte[] data = Encoding.ASCII.GetBytes(response);
socket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(sendCallback), socket);
socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, new AsyncCallback(receiveCallback), socket);
}
private static void sendCallback(IAsyncResult AR)
{
Socket socket = (Socket)AR.AsyncState;
socket.EndSend(AR);
}
}
}
And this on my client
using System;
using System.Text;
using System.Net;
using System.Net.Sockets;
namespace Multiple_Clients
{
class Program
{
private static int port = 4567;
private static Socket _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
static void Main(string[] args)
{
Console.Title = "Client";
connect();
sendLoop();
Console.ReadLine();
}
private static void connect()
{
int attempts = 0;
while(!_clientSocket.Connected)
{
try
{
attempts++;
_clientSocket.Connect(IPAddress.Loopback, port);
}
catch(SocketException)
{
Console.Clear();
Console.WriteLine("Connection attempts: " + attempts.ToString());
}
}
Console.Clear();
Console.WriteLine("Connected");
}
private static void sendLoop()
{
while (true)
{
Console.Write("Enter a request:");
string req = Console.ReadLine();
byte[] buffer = Encoding.ASCII.GetBytes(req);
_clientSocket.Send(buffer);
byte[] receivedBuf = new byte[1024];
int rec = _clientSocket.Receive(receivedBuf);
byte[] data = new byte[rec];
Array.Copy(receivedBuf, data, rec);
Console.WriteLine("Received: " + Encoding.ASCII.GetString(data));
}
}
}
}
Any suggestions on how to improve this question are welcome.
Thank you very much for helping me!
Your client allways connect to IPAddress.Loopback ... in fact the local IP Address 127.0.0.1. Exchange IPAddress.Loopback to the real IPAdress of your server, e. g. IPAddress.Parse("192.168.?.?") ...!
I've been working on a chat for 2 people. everything is great (i have some exceptions to solve, but no big deal).
but the problem is, when i send a message from the client to server, then server to client, the server sends the last message it got from the client and only after you send again, it sends the right message and the other way around.
Client
private Socket _socket;
private byte[] _buffer;
private bool ok = false;
private ListBox _listbox;
public ClientSocket(ListBox list)
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listbox = list;
}
public void Connect(string ipAddress, int port)
{
_socket.BeginConnect(new IPEndPoint(IPAddress.Parse(ipAddress), port), ConnectedCallback, null);
if(ok)
Item("Connected to the server!");
else Item("Could not Connect to the server!");
}
public void SendMessage(string text)
{
_buffer = new byte[1024];
_buffer = Encoding.Default.GetBytes(text);
_socket.BeginSend(_buffer, 0, _buffer.Length, SocketFlags.None, SentCallback, null);
}
private void ConnectedCallback(IAsyncResult result)
{
if (_socket.Connected)
{
_socket.EndConnect(result);
_buffer = new byte[1024];
_socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, null);
ok = true;
}
}
private void ReceivedCallback(IAsyncResult result)
{
//_buffer = new byte[1024];
int bufLength = _socket.EndReceive(result);
//byte[] packet = new byte[bufLength];
//Array.Copy(_buffer, packet, packet.Length);
Array.Resize(ref _buffer, bufLength);
Item(PacketHandler.Handle(_buffer, _socket));
//PacketHandler.Handle(packet, _socket);
_buffer = new byte[1024];
_socket.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, null);
}
private void SentCallback(IAsyncResult result)
{
_socket.EndSend(result);
//_buffer = new byte[1024];
}
public void Item(string text)
{
if (_listbox.InvokeRequired)
{
_listbox.Invoke(new Action<string>(Item), text);
return;
}
_listbox.Items.Add(text);
}
server
private Socket _socket;
private Socket _client;
private byte[] _buffer = new byte[1024];
private ListBox _listbox;
public ServerSocket(ListBox list)
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_listbox = list;
}
public void Bind(int port)
{
_socket.Bind(new IPEndPoint(IPAddress.Any, port));
Item("Server Started");
}
public void Listen(int backlog)
{
_socket.Listen(backlog);
Item("Listening...");
}
public void Accept()
{
_socket.BeginAccept(AcceptedCallback, null);
}
public void SendMessage(string text)
{
_buffer = new byte[1024];
_buffer = Encoding.Default.GetBytes(text);
_client.BeginSend(_buffer, 0, _buffer.Length, SocketFlags.None, SentCallback, null);
}
private void AcceptedCallback(IAsyncResult result)
{
_client = _socket.EndAccept(result);
_buffer = new byte[1024];
_client.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, _client);
//_listbox.Items.Add("Accepted User" + _socket.LocalEndPoint.AddressFamily.ToString() + " ");
//Accept();
}
private void ReceivedCallback(IAsyncResult result)
{
try
{
//_client = result.AsyncState as Socket;
int bufLength = _client.EndReceive(result);
//byte[] packet = new byte[bufferSize];
//Array.Copy(_buffer, packet, packet.Length);
Array.Resize(ref _buffer, bufLength);
Item(PacketHandler.Handle(_buffer, _client));
//Item(PacketHandler.Handle(packet, clientSocket));
//_listbox.Items.Add(PacketHandler.Handle(packet, clientSocket));
_buffer = new byte[1024];
_client.BeginReceive(_buffer, 0, _buffer.Length, SocketFlags.None, ReceivedCallback, _client);
}
catch (SocketException)
{
Item(("User " + _client.LocalEndPoint.ToString() + " has disconnected"));
}
}
private void SentCallback(IAsyncResult result)
{
_client.EndSend(result);
//_buffer = new byte[1024];
}
public void Item(string text)
{
if (_listbox.InvokeRequired)
{
_listbox.Invoke(new Action<string>(Item), text);
return;
}
_listbox.Items.Add(text);
}
cant find a way to fix it, is my code correct?
btw im not a native speaker so bear with my understanding problems :D
_buffer member variable is being used for all send/receive/accept operations. This can cause serious problems, try using separate member buffer variable for each operation.
Basically I made two C# applications, a client and a server. The client connects to the server (via sockets), then sends a packet containing some text, and the server should reply.
My problem is: the server sends (or the client receives) the response packet only when it closes (ALT+F4). I'd like some help. I'll copypaste below the source code for both the projects.
Client:
public class StateObject
{
public Socket skt = null;
public const int BufferSize = 256;
public byte[] buffer = new byte[BufferSize];
public StringBuilder sb = new StringBuilder();
}
public class AsynchronousClient
{
private const int port = 11000;
private static ManualResetEvent connectDone =
new ManualResetEvent(false);
private static ManualResetEvent sendDone =
new ManualResetEvent(false);
private static ManualResetEvent receiveDone =
new ManualResetEvent(false);
private static String response = String.Empty;
public static string command;
public static Socket client;
public static void StartClient()
{
try
{
IPHostEntry ipHostInfo = Dns.GetHostEntry(IPAddress.Parse("127.0.0.1"));
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
client = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
client.BeginConnect(remoteEP,
new AsyncCallback(ConnectCallback), client);
connectDone.WaitOne();
while (true)
{
command = Console.ReadLine();
if (command == "exit")
{
Console.WriteLine("Terminating...");
client.Shutdown(SocketShutdown.Both);
client.Close();
Environment.Exit(0);
}
else
{
Send(client, command + "<EOF>");
sendDone.WaitOne();
Receive(client);
receiveDone.WaitOne();
Console.WriteLine("Response received : {0}", ProcessResponse(response));
client.Shutdown(SocketShutdown.Both);
client.Close();
}
//Console.CancelKeyPress += (sender, e) =>
//{
// Console.WriteLine("Terminating...");
// client.Shutdown(SocketShutdown.Both);
// client.Close();
// Environment.Exit(0);
//};
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
static public string ProcessResponse(string pkt)
{
string response = null;
response = pkt.Replace("<EOF>","");
return response;
}
private static void ConnectCallback(IAsyncResult ar)
{
try
{
Socket client = (Socket)ar.AsyncState;
client.EndConnect(ar);
Console.WriteLine("Socket connected to {0}",
client.RemoteEndPoint.ToString());
connectDone.Set();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void Receive(Socket client)
{
try
{
StateObject state = new StateObject();
state.skt = client;
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
StateObject state = (StateObject)ar.AsyncState;
Socket client = state.skt;
int bytesRead = client.EndReceive(ar);
if (bytesRead > 0)
{
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
else
{
if (state.sb.Length > 1)
{
response = state.sb.ToString();
}
receiveDone.Set();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private static void Send(Socket client, String data)
{
byte[] byteData = Encoding.ASCII.GetBytes(data);
client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client);
}
private static void SendCallback(IAsyncResult ar)
{
try
{
Socket client = (Socket)ar.AsyncState;
int bytesSent = client.EndSend(ar);
Console.WriteLine("Sent {0} bytes to server.", bytesSent);
sendDone.Set();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public static int Main(String[] args)
{
StartClient();
return 0;
}
Server:
public class Program
{
public class StateObject
{
public Socket skt = null;
public const int buffersize = 1024;
public byte[] buffer = new byte[buffersize];
public StringBuilder sb = new StringBuilder();
}
public class AsynchronousSocketListener
{
public static ManualResetEvent allDone = new ManualResetEvent(false);
public AsynchronousSocketListener() { }
public static Socket handler;
public static void StartListening()
{
byte[] bytes = new Byte[1024];
IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 11000);
Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
listener.Bind(localEndPoint);
listener.Listen(100);
while (true)
{
allDone.Reset();
Console.WriteLine("Waiting for a connection...");
listener.BeginAccept(
new AsyncCallback(AcceptCallback),
listener);
allDone.WaitOne();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
Console.WriteLine("\nPress ENTER to continue...");
Console.Read();
}
public static void AcceptCallback(IAsyncResult ar)
{
allDone.Set();
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);
StateObject state = new StateObject();
state.skt = handler;
handler.BeginReceive(state.buffer, 0, StateObject.buffersize, 0, new AsyncCallback(ReadCallback), state);
}
public static void ReadCallback(IAsyncResult ar)
{
String content = String.Empty;
StateObject state = (StateObject)ar.AsyncState;
Socket handler = state.skt;
int bytesRead = handler.EndReceive(ar);
if (bytesRead > 0)
{
state.sb.Append(Encoding.ASCII.GetString(
state.buffer, 0, bytesRead));
content = state.sb.ToString();
if (content.IndexOf("<EOF>") > -1)
{
Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, ProcessResponse(content));
Send(handler, content);
}
else
{
handler.BeginReceive(state.buffer, 0, StateObject.buffersize, 0,
new AsyncCallback(ReadCallback), state);
}
}
}
private static void Send(Socket handler, String data)
{
byte[] byteData = Encoding.ASCII.GetBytes(data);
handler.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), handler);
}
private static void SendCallback(IAsyncResult ar)
{
try
{
handler = (Socket)ar.AsyncState;
int bytesSent = handler.EndSend(ar);
Console.WriteLine("Sent {0} bytes to client.", bytesSent);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
static public string ProcessResponse(String pkt)
{
string response = null;
response = pkt.Replace("<EOF>", "");
return response;
}
}
public static void Main(string[] args)
{
AsynchronousSocketListener.StartListening();
}
}
In your Client receive callback:
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
StateObject state = (StateObject)ar.AsyncState;
Socket client = state.skt;
int bytesRead = client.EndReceive(ar);
if (bytesRead > 0)
{
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
else
{
if (state.sb.Length > 1)
{
response = state.sb.ToString();
}
receiveDone.Set();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
You won't ever drop down into the else block unless the socket is explicitly closed (or there is some kind of other error in the connection). Therefore receiveDone never gets set and your main loop is simply stuck waiting for a "response".
If you want to process a "complete message" when it comes in, then check for your <EOF> value after you append the current string to your buffer like this:
if (bytesRead > 0)
{
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
// it's not a "response" unless it's terminated with "<EOF>" right?
response = state.sb.ToString();
if (response.IndexOf("<EOF>") != -1)
{
state.sb.Clear();
receiveDone.Set();
}
else
{
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
new AsyncCallback(ReceiveCallback), state);
}
}
else
{
if (state.sb.Length > 1)
{
response = state.sb.ToString(); // this is a partial response, not terminated with "<EOF>"
}
receiveDone.Set();
}
Note that response mechanism being used is extremely limited as it would fail for multiple messages coming in at the same time like: Hello<EOF> World!<EOF> It would treat those two messages as one long message. (I realize your example is only sending one "message".)
You're almost certainly going to have to deal with that scenario in any real world application that sends "control" messages in addition to "content" messages. To handle that you'd look for <EOF> using IndexOf() and extract the text up to that point and process that "complete message". Afterwards you'd keep looping as long as <EOF> is still found to process the other pending messages. You'd also have to REMOVE those processed complete messages from the StringBuilder in such a way that any remaining values after the <EOF> are left in place so that when partial messages come in the new data can be appended to the existing data. This is because your data can also be split up when it is sent, resulting in multiple "chunks" of data being received even though it is logically one "complete message" when you sent it. So one send with Complete Message<EOF> could result in one or more receives such as Comp followed by lete Message<EOF>. Your code has to be able to deal with these realities of TCP communication...
Ok so I have a socket connection within my code that is causing a problem. It connects and then disconnects rather quickly. It disconnects after the "connections++;" line. Any ideas?
AS REQUESTED ALL CODE FOR THIS FORM BELOW
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
namespace Middleware
{
public partial class Middleware : Form
{
//variables
private Socket server;
private Socket remoteclient;
private Socket clientreturn;
private Socket serversync;
private byte[] data = new byte[1024];
private byte[] datars = new byte[1024];
private int connections = 0;
public Middleware()
{
InitializeComponent();
Control.CheckForIllegalCrossThreadCalls = false;
}
private void Middleware_Load(object sender, EventArgs e)
{
}
void OnConnectedRemote(IAsyncResult result)
{
try
{
remoteclient.EndConnect(result);
}
catch
{
remoteclient.Close();
}
}
void OnConnected(IAsyncResult result)
{
Socket client = server.EndAccept(result);
connections++;
server.BeginAccept(new AsyncCallback(OnConnected), null);
try
{
txtStatus.Text = "" + connections;
byte[] message = Encoding.ASCII.GetBytes("Welcome to my server");
client.BeginSend(message, 0, message.Length, SocketFlags.None, new AsyncCallback(OnDataSent), client);
}
catch
{
client.Close();
}
}
void OnConnectedSync(IAsyncResult result)
{
Socket sync = serversync.EndAccept(result);
connections++;
//serversync.BeginAccept(new AsyncCallback(OnConnectedSync), null);
try
{
txtStatus.Text = "" + connections;
byte[] message = Encoding.ASCII.GetBytes("Connected to Middleware");
sync.BeginSend(message, 0, message.Length, SocketFlags.None, new AsyncCallback(OnDataSentSync), sync);
}
catch
{
sync.Close();
}
}
void OnDataSent(IAsyncResult result)
{
Socket client = (Socket)result.AsyncState;
try
{
//end send and begin receive from client
int sent = client.EndSend(result);
client.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), client);
}
catch (SocketException)
{
//close client
client.Close();
}
}
void OnDataSentSync(IAsyncResult result)
{
Socket sync = (Socket)result.AsyncState;
try
{
//end send and begin receive from client
int sent = sync.EndSend(result);
sync.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceivedSync), sync);
}
catch (SocketException)
{
//close client
sync.Close();
}
}
void OnDataReceivedSync(IAsyncResult result)
{
Socket sync = (Socket)result.AsyncState;
//clientreturn = (Socket)result.AsyncState;
}
void OnDataSentWaiting(IAsyncResult result)
{
Socket sync = (Socket)result.AsyncState;
try
{
//end send and begin receive from client
int sent = sync.EndSend(result);
//sync.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), sync);
}
catch (SocketException)
{
//close client
sync.Close();
}
}
void OnDataReceived(IAsyncResult result)
{
Socket client = (Socket)result.AsyncState;
clientreturn = (Socket)result.AsyncState;
try
{
//if nothing is received then close connection
//otherwise get message and add to list box
//create newsocket, bind and listen to create server connection
//begin accept
int receive;
receive = client.EndReceive(result);
//string port = (((IPEndPoint)client.RemoteEndPoint).Port.ToString ());
if (receive == 0)
{
client.Close();
return;
}
else
{
string message = Encoding.ASCII.GetString(data, 0, receive);
lstAll.Items.Add(message);
txtSent.Text = message;
byte[] echomessage = Encoding.ASCII.GetBytes(message);
bool check = remoteclient.Poll(1000, SelectMode.SelectRead);
bool avail = (remoteclient.Available == 0);
if (check & avail)
{
btnConnect.Enabled = true;
btnDisconnect.Enabled = false;
MessageWait(message);
//serversync.BeginSend(echomessage, 0, echomessage.Length, SocketFlags.None, new AsyncCallback(OnDataSentWaiting), serversync);
//client.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), client);
}
else
{
client.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnDataReceived), client);
remoteclient.BeginSend(echomessage, 0, echomessage.Length, SocketFlags.None, new AsyncCallback(OnRemoteDataSent), remoteclient);
}
}
}
catch (SocketException)
{
//close client
client.Close();
}
}
private void MessageWait(string message)
{
byte[] echomessage = Encoding.ASCII.GetBytes(message);
serversync.BeginSend(echomessage, 0, echomessage.Length, SocketFlags.None, new AsyncCallback(OnDataSentSync), null);
}
void OnRemoteDataSent(IAsyncResult result)
{
try
{
int sent = remoteclient.EndSend(result);
remoteclient.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(OnRemoteDataReceived), null);
}
catch (SocketException)
{
//close server connection
remoteclient.Close();
}
}
void OnRemoteDataReceived(IAsyncResult result)
{
try
{
int receive = remoteclient.EndReceive(result);
string message = Encoding.ASCII.GetString(data, 0, receive);
txtReceived.Text = message + " from Middle";
datars = Encoding.ASCII.GetBytes(txtReceived.Text);
clientreturn.BeginSend(datars, 0, datars.Length, SocketFlags.None, new AsyncCallback(OnDataSentBack), clientreturn);
}
catch (SocketException)
{
//close server
clientreturn.Close();
}
}
void OnDataSentBack(IAsyncResult result)
{
Socket client = (Socket)result.AsyncState;
try
{
int sent = client.EndSend(result);
}
catch (SocketException)
{
//closeserver
client.Close();
}
}
private void btnConnect_Click(object sender, EventArgs e)
{
try
{
btnConnect.Enabled = false;
remoteclient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse(txtIP.Text), 2000);
remoteclient.BeginConnect(remoteEndPoint, new AsyncCallback(OnConnectedRemote), null);
}
catch
{
remoteclient.Close();
}
}
private void btnStart_Click(object sender, EventArgs e)
{
int port;
port = int.Parse(txtPort.Text);
btnStart.Enabled = false;
server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint localEP = new IPEndPoint(0, port);
server.Bind(localEP);
server.Listen(4);
server.BeginAccept(new AsyncCallback(OnConnected), null);
txtStatus.Text = "Waiting for client...";
}
private void btnSyncC_Click(object sender, EventArgs e)
{
int port;
port = int.Parse(txtPort.Text);
btnStart.Enabled = false;
serversync = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint localEP2 = new IPEndPoint(0, port);
serversync.Bind(localEP2);
serversync.Listen(1);
serversync.BeginAccept(new AsyncCallback(OnConnectedSync), null);
txtStatus.Text = "Waiting for sync client...";
}
}
}
I bet that there is something wrong with the txtStatus object, and you are actually getting a NullReferenceException which is caught, ignored, and causes the socket to immediately close.