We Keep Coding

C# client socket multiple send and receive

I am using sockets for TCP-IP connection and I would like to establish simple system send-receive from the client side.
Socket sck;
sck = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint localEndpt = new IPEndPoint(IPAddress.Parse("123.123.123.1"), 12345);
try
{
sck.Connect(localEndpt);
}
catch
{
Console.Write("Unable to Connect");
}
while (true)
{
Console.WriteLine("Enter Text");
string sendtext = Console.ReadLine();
byte[] Data = Encoding.ASCII.GetBytes(sendtext);
sck.Send(Data);
Console.WriteLine("Data Sent!");
byte[] bytesReceived = new byte[sck.ReceiveBufferSize];
int bytes = 0;
String strReceived = "";
int dataAvailable = 0;
while (dataAvailable == 0 || dataAvailable != sck.Available)
{
dataAvailable = sck.Available;
Thread.Sleep(100); // if no new data after 100ms assume transmission finished
}
if (sck.Available > 0)
{
bytes = sck.Receive(bytesReceived, bytesReceived.Length, 0);
strReceived+=Encoding.ASCII.GetString(bytesReceived, 0, bytes);
}
Console.WriteLine("Received from server: " + strReceived);
}
Console.Read();
The problem is that first requests goes throught but the second does not, because socket is not available anymore (socket "Availabe" attribute value is 0). What am I doing wrong? What would be the easiest way to establish multiple send-recieve requests (in order)?

This code works fine for me
private List<Socket> _clients = new List<Socket>();
private Thread _dataReceiveThread;
private bool _isConnected;
private void DataReceive()
{
while (_isConnected)
{
List<Socket> clients = new List<Socket>(_clients);
foreach (Socket client in clients)
{
try
{
if (!client.Connected) continue;
string txt = "";
while (client.Available > 0)
{
byte[] bytes = new byte[client.ReceiveBufferSize];
int byteRec = client.Receive(bytes);
if (byteRec > 0)
txt += Encoding.UTF8.GetString(bytes, 0, byteRec);
}
if (!string.IsNullOrEmpty(txt))
/* TODO: access the text received with "txt" */
}
catch (Exception e)
{
Exception_Handler(e);
}
}
}
}
Just run this code to get started
_isConnected = true;
_dataReceiveThread = new Thread(DataReceive);
_dataReceiveThread.Start();
Update list box in Cross thread:
This code can be placed in the comment section.
myListBox1.Invoke((Action)(() => { myListBox1.Items.Add(txt) }));

Socket. Available does NOT indicate whether the socket is available, but incoming data is available for reading:
https://msdn.microsoft.com/en-us/library/ee425135.aspx
Your program quits because it checks for a reply (incoming data) immediately after sending a message out. Use a Thread.Sleep before checking for data.
Maybe the message has not even been sent, because Socket.Send just places it in the network interface card's output buffer. When the socket finally sends the message, it will upare the connection state. If it got no reply (on a TCP connection), it will tell you that it is disconnected when you query the state. On UDP it will tell you nothing, because UDP is connectionless.

How to block Send in TCP if already contain data in buffer to process at client side

I have been using TCP sockets to send and recieve data from server to client.
I am using following code
Server
private string SendDataToClient(int currentStationSeq, int nextStationSeq, int SequenceOrder)
{
byte[] byData = System.Text.Encoding.ASCII.GetBytes(String.Format("{0},{1},{2}", currentStationSeq, nextStationSeq, SequenceOrder));
Socket workerSocket = null;
for (int i = 0; i < m_workerSocketList.Count; i++)
{
workerSocket = (Socket)m_workerSocketList[i];
if (workerSocket != null)
{
if (workerSocket.Connected)
{
workerSocket.Send(byData);
}
}
}
}
Client
public void OnDataReceived(IAsyncResult asyn)
{
try
{
SocketPacket theSockId = (SocketPacket)asyn.AsyncState;
int iRx = theSockId.thisSocket.EndReceive(asyn);
char[] chars = new char[iRx + 1];
string szData = new string(chars);
//Console.WriteLine(szData);
string[] arrData = szData.Split(',');
if (arrData.Length == 3)
{
// Some code
}
else if (arrData.Length == 2)
{
// Some Code
}
else if (arrData.Length == 1)
{
}
WaitForData();
}
catch (ObjectDisposedException)
{
System.Diagnostics.Debugger.Log(0, "1", "\nOnDataReceived: Socket has been closed\n");
}
catch (SocketException se)
{
}
}
It works fine when Server not sending continuously. But in case when Server send data faster than Client process it, data gets starting to accumulate in buffer. When client reads it from buffer, it reads all data from buffer, thus break my logic.
I need something like if Server send data to client, it must wait for data to process at client side before sending any new data.
How it is possible ??

How to handle weird socket request (HTTP server)

I've written my own HTTP server to embed in a desktop application and it works (spins up a server on localhost), except that I'm getting a strange request on the socket that is causing the connection to be closed so that no new requests are being handled. The request is occuring about 15 seconds after I open the web page. The packet contains a long series of \0\0\0\0\0\0\0\0\0\0\0\0...... when I examine it. I have no idea what's causing this or how to handle it. For those first 15 seconds, I'm able to do everything I need to do, but once this happens, no new requests can be made and the server won't respond to any new requests. It also doesn't happen every time I launch the application but I can't pin down why.
while (true)
{
//Accept a new connection
Socket mySocket = _listener.AcceptSocket();
if (mySocket.Connected)
{
Byte[] bReceive = new Byte[1024];
int i = mySocket.Receive(bReceive, bReceive.Length, 0);
string sBuffer = Encoding.ASCII.GetString(bReceive);
if (sBuffer.Substring(0, 3) != "GET")
{
Console.WriteLine(sBuffer);
mySocket.Close();
return;
}
........handle valid requests
}
}

Try something like this:
while (true)
{
//Accept a new connection
Socket mySocket = _listener.AcceptSocket();
if (mySocket.Connected)
{
Byte[] bReceive = new Byte[1024];
int i = mySocket.Receive(bReceive, bReceive.Length, 0);
if(i > 0) // added check to make sure data is received
{
string sBuffer = Encoding.ASCII.GetString(bReceive, 0, i); // added index and count
if (sBuffer.Substring(0, 3) != "GET")
{
Console.WriteLine(sBuffer);
mySocket.Close();
return;
}
........handle valid requests
}
}
}
Ultimately - you will need to do something if i == 1024 - because if it does, there is more data than you are reading in mySocket.Receive.
As a side note - I might change
if (sBuffer.Substring(0, 3) != "GET")
to
if (sBuffer.StartsWith("GET"))
It's slightly easier to read - and has the added benefit of not requiring a change to the substring length if (for some odd reason) GET changed to something else.
Edit - this will allow for multiple calls to mySocket.Receive when more data than 1024 bytes is encountered:
while (true)
{
//Accept a new connection
Socket mySocket = _listener.AcceptSocket();
if (mySocket.Connected)
{
StringBuilder sb = new StringBuilder();
Byte[] bReceive = new Byte[1024];
int i;
while ((i = mySocket.Receive(bReceive, bReceive.Length, 0) > 0))
{
sb.Append(Encoding.ASCII.GetString(bReceive, 0, i)); // added index and count
}
string sBuffer = sb.ToString();
if (sBuffer.Substring(0, 3) != "GET")
{
Console.WriteLine(sBuffer);
mySocket.Close();
return;
}
}
}

Unity TCP server/client

I'm sorry but I'm kinda having a confusing problem here...
I was using Unity recently and try to make a simple TCP server that can broadcast through all its clients, also to himself where the server itself is one of the client, like chat room or something.
so I did successfully done so, but the problem is, all the data that received by the client is actually twice of the initially data send from client, below is the example of my code
public void broadcast(string data)
{
print("Broadcast");
byte[] dataByte = Encoding.ASCII.GetBytes(data);
print(ClientList.Count);
for(int x = 0; x<ClientList.Count;x++)
{
ClientList[x].Send(dataByte);
print ("something" +ClientList[x].Send(dataByte));
print ("loop");
}
}
and this is how the client will receive it
private void ReceiveData(IAsyncResult ar)
{
print ("ReceiveData Client");
Socket handler = (Socket)ar.AsyncState;
try
{
int x = handler.EndReceive(ar);
print("Receiving Data...");
print (x);
if (x > 0)
{
StringBuilder sb = new StringBuilder();
sb.Append(Encoding.ASCII.GetString(buffer, 0, x));
string content = sb.ToString();
print("Data Received: " + content);
//string[] data = content.Split(';');
//for (int i = 0; i < data.Length; i++)
//{
this.ProcessData(x, content, handler);
//}
sb.Remove(0, sb.Length);
handler.BeginReceive(buffer, 0, 1024, 0, new AsyncCallback(ReceiveData), handler);
}
else
{
print("Connection Closed...");
}
}
catch (Exception e)
{
print(e.Message);
}
}
I try to send test;this is client
and the result is below
Broadcast
1
something20
ReceiveData Client
loop
Receiving data...
40
Data Received: test;this is client test; this is client"
I don't know what or how this went wrong, any help will be appreciated. Thanks b4

The problem is within these two lines:
ClientList[x].Send(dataByte);
print ("something" +ClientList[x].Send(dataByte));
Notice how you've executed ClientList[x].Send(dataByte) twice? That's why you're getting it 2 times on the receiving end. Just remove one of the two lines and you should be fine.

C# async Begin Receive Call back method misses some packets

I send 2 successive packets from my client to the server who is listening using BeginReceive
The server always receives the first packet but not the other EXCEPT if I run the client in debug mode and slowly send the next packet after the other.
Here's a snippet from my sending function
if (soc.Connected)
{
byte[] byData = new byte[System.Text.Encoding.ASCII.GetByteCount("Hi")];
byData = System.Text.Encoding.ASCII.GetBytes("Hi");
soc.Send(BitConverter.GetBytes(byData.Length));
soc.Send(byData);
}
And here's is my call back function located inside of my server:
private void Recieve(IAsyncResult iar)
{
int j = 0;
Socket server_conn = (Socket)iar.AsyncState;
server_conn.EndReceive(iar);
if (!SocketConnected(server_conn))
{
server_conn.Close();
return;
}
if (g_bmsg.Length != 0)
{
logthis(server_conn.RemoteEndPoint.ToString() + ": " + Encoding.ASCII.GetString(g_bmsg, 0, g_bmsg.Length));
}
//Find out who sent this
foreach (ClientData cls in clientlist)
{
if (server_conn.RemoteEndPoint == cls.clientsock.RemoteEndPoint)
{
j = cls.index;
break;
}
}
server_conn.BeginReceive(g_bmsg, 0, g_bmsg.Length, SocketFlags.None, new AsyncCallback(Recieve), server_conn);
}

When working with TCP/IP sockets (or pretty much any communication layer), you rarely have a guarantee that the entire message you intended to send will come in a single packet.
This means that you should always keep a FIFO buffer of your own, and parse it sequentially.
This is the general idea:
// fifo queue (for background thread parsing, make sure it's thread safe)
private readonly ConcurrentQueue<byte> _commQueue = new ConcurrentQueue<byte>();
In your Receive method, you should simply enqueue the data to the FIFO:
private void Receive(IAsyncResult iar)
{
Socket server_conn = (Socket)iar.AsyncState;
// check how many bytes we actually received
var numBytesReceived = server_conn.EndReceive(iar);
if (!SocketConnected(server_conn))
{
server_conn.Close();
return;
}
// get the received data from the buffer
if (numBytesReceived > 0)
{
for (int i = 0; i < numBytesReceived; i++)
_commQueue.Enqueue(g_bmsg[i]);
// signal the parser to continue parsing
NotifyNewDataReceived();
}
// continue receiving
server_conn.BeginReceive(g_bmsg, 0, g_bmsg.Length, SocketFlags.None, new AsyncCallback(Recieve), server_conn);
}