private bool ReceiveMessageFromServer(ISocket server, Buffer recvBuffer)
{
bool CLIENT_EXIT_FLAG = false;
do
{
var bytesReceived = AweSock.ReceiveMessage(server, recvBuffer);
if (bytesReceived.Item1 > 0)
CLIENT_EXIT_FLAG = true;
else if (bytesReceived.Item1 == 0)
return false;
Thread.Sleep(1000);
} while (!CLIENT_EXIT_FLAG);
return true;
}
public static Tuple<int, EndPoint> ReceiveMessage(ISocket socket, Buffer buffer, SocketCommunicationTypes type = SocketCommunicationTypes.Blocking, MessageThreadCallback callback = null)
{
if (type == SocketCommunicationTypes.Blocking)
{
switch (socket.GetSocket().ProtocolType)
{
case ProtocolType.Tcp:
return Tuple.Create(socket.GetSocket().Receive(Buffer.GetBufferRef(buffer)), socket.GetSocket().RemoteEndPoint);
case ProtocolType.Udp:
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
return Tuple.Create(socket.GetSocket().ReceiveFrom(Buffer.GetBufferRef(buffer), ref remoteEndPoint), remoteEndPoint);
default:
throw new ConstraintException("Socket must be of type TCP or UDP.");
}
}
if (callback == null) throw new ArgumentNullException(string.Format("{0}=null; You must provide a valid callback when using the NonBlocking type", "callback"));
new Thread(() => MessageReceiveThread(socket, buffer, callback)).Start();
return Tuple.Create(-1, new IPEndPoint(-1, -1) as EndPoint); //Return negative 1 as 0 bytes received is valid and we want an invalid value
}
private bool ReceiveResponseFromClient(ISocket client, Buffer recvBuffer)
{
bool SERVER_EXIT_FLAG = false;
do
{
var bytesReceived = AweSock.ReceiveMessage(client, recvBuffer);
if (bytesReceived.Item1 > 0)
{
if (!ValidateResponse(recvBuffer))
return false;
SERVER_EXIT_FLAG = true;
}
else if (bytesReceived.Item1 == 0)
return false;
//Thread.Sleep(1000);
} while (!SERVER_EXIT_FLAG);
return true;
}
public Tuple<int, EndPoint> ReceiveMessage(string ip, int port, Buffer buffer)
{
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);
return Tuple.Create(InternalSocket.ReceiveFrom(Buffer.GetBufferRef(buffer), ref remoteEndPoint), remoteEndPoint);
}
public Tuple<int, EndPoint> ReceiveMessage(Buffer buffer)
{
return Tuple.Create(InternalSocket.Receive(Buffer.GetBufferRef(buffer)), InternalSocket.RemoteEndPoint);
}
public static int SendMessage(ISocket socket, string ip, int port, Buffer buffer)
{
if (socket.GetSocket().ProtocolType == ProtocolType.Tcp) throw new ConstraintException("Cannot call this method with a TCP socket. Call SendMessage(Socket, Buffer) instead.");
return socket.SendMessage(ip, port, buffer);
}
public int SendMessage(Buffer buffer)
{
return(InternalSocket.Send(Buffer.GetBuffer(buffer), 0, (int)Buffer.GetWrittenBytes(buffer), 0));
}
private bool ValidateResponse(Buffer receiveBuffer)
{
return ((Buffer.Get<int>(receiveBuffer) == 10) && (Buffer.Get<float>(receiveBuffer) == 20.0F) && (Buffer.Get<double>(receiveBuffer) == 40.0) && (Buffer.Get<char>(receiveBuffer) == 'A') &&
(Buffer.Get<string>(receiveBuffer) == "The quick brown fox jumped over the lazy dog") && (Buffer.Get<byte>(receiveBuffer) == ((byte)255)));
}
public void ClearBuffer_ThrowsArgumentNullException_WhenBufferIsNull()
{
Assert.Throws <ArgumentNullException>(() => Buffer.ClearBuffer(null));
}
public void Add_ThrowsBufferFinalizedException_WhenBufferIsFinalized()
{
var testBuffer = CreateValidBuffer();
Assert.Throws <InvalidOperationException>(() => Buffer.Add(testBuffer, 1));
}
public void Add_ThrowsArgumentNullException_WhenBufferIsNull()
{
Assert.Throws <ArgumentNullException>(() => Buffer.Add(null, 4));
}
public void GetBuffer_ThrowsBufferFinalizedException_WhenBufferIsntFinalized()
{
var invalidBuffer = CreateInvalidBuffer();
Assert.Throws <InvalidOperationException>(() => Buffer.GetBuffer(invalidBuffer));
}
public void FinalizeBuffer_DoesntThrowBufferFinalizedException_IfBufferIsAlreadyFinalized()
{
var testBuffer = CreateValidBuffer();
Buffer.FinalizeBuffer(testBuffer);
}
public int ReceiveMessage(string ip, int port, Buffer buffer)
{
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);
return(InternalSocket.ReceiveFrom(Buffer.GetBufferRef(buffer), ref remoteEndPoint));
}
public int ReceiveMessage(Buffer buffer)
{
return(InternalSocket.Receive(Buffer.GetBufferRef(buffer)));
}
public int SendMessage(Buffer buffer)
{
return InternalSocket.Send(Buffer.GetBuffer(buffer));
}
public int SendMessage(string ip, int port, Buffer buffer)
{
var ipAddress = IPAddress.Parse(ip);
var remoteEndpoint = new IPEndPoint(ipAddress, port);
return InternalSocket.SendTo(Buffer.GetBuffer(buffer), remoteEndpoint);
}
public void FinalizeBuffer_ArgumentNullException_WhenBufferIsNull()
{
Assert.Throws <ArgumentNullException>(() => Buffer.FinalizeBuffer(null));
}
public void FinalizeBuffer_DoesntThrowBufferFinalizedException_IfBufferIsAlreadyFinalized()
{
var testBuffer = CreateValidBuffer();
Assert.DoesNotThrow(() => Buffer.FinalizeBuffer(testBuffer));
}
private static void MessageReceiveThread(ISocket socket, Buffer buffer, MessageThreadCallback callback)
{
int bytes;
switch (socket.GetProtocolType())
{
case ProtocolType.Tcp:
bytes = socket.GetSocket().Receive(Buffer.GetBufferRef(buffer));
callback(bytes);
break;
case ProtocolType.Udp:
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
bytes = socket.GetSocket().ReceiveFrom(Buffer.GetBufferRef(buffer), ref remoteEndPoint);
callback(bytes, remoteEndPoint);
break;
default:
callback(-1);
break;
}
}
private void SendTestMessage(ISocket other, Buffer sendBuffer)
{
Buffer.ClearBuffer(sendBuffer);
Buffer.Add(sendBuffer, 10);
Buffer.Add(sendBuffer, 20.0F);
Buffer.Add(sendBuffer, 40.0);
Buffer.Add(sendBuffer, 'A');
Buffer.Add(sendBuffer, "The quick brown fox jumped over the lazy dog");
Buffer.Add(sendBuffer, (byte)255);
Buffer.FinalizeBuffer(sendBuffer);
var bytesSent = AweSock.SendMessage(other, sendBuffer);
Console.WriteLine("Sent payload. {0} bytes written.", bytesSent);
}
public static int ReceiveMessage(ISocket socket, Buffer buffer, int offset = 0, SocketCommunicationTypes type = SocketCommunicationTypes.Blocking,
MessageThreadCallback callback = null)
{
if (type == SocketCommunicationTypes.Blocking)
{
switch (socket.GetSocket().ProtocolType)
{
case ProtocolType.Tcp:
return(socket.GetSocket().Receive(Buffer.GetBufferRef(buffer), offset, Buffer.GetSize(buffer) - offset, 0));
case ProtocolType.Udp:
EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
return(socket.GetSocket().ReceiveFrom(Buffer.GetBufferRef(buffer), offset, Buffer.GetSize(buffer) - offset, 0, ref remoteEndPoint));
default:
throw new InvalidOperationException("Socket must be of type TCP or UDP.");
}
}
if (callback == null)
{
throw new ArgumentNullException(string.Format("{0}=null; You must provide a valid callback when using the NonBlocking type", "callback"));
}
new Thread(() => MessageReceiveThread(socket, buffer, callback)).Start();
return(-1); //Return negative 1 as 0 bytes received is valid and we want an invalid value
}
