public static void ReturnNamedResourceAsWebPage(HttpMessage httpMessage, ISocketProxy socketProxy)
{
string destinationUrl = httpMessage.Headers.DestinationUrl().Substring(1);
var resourceStream = new ResourceReader().GetResource(destinationUrl);
var bytes = resourceStream.ReadFully();
socketProxy.SendWebPage(Encoding.ASCII.GetString(bytes));
}
public byte[] Read(ISocketProxy proxy)
{
int totalLength = BitConverter.ToInt32(ReadUntil(proxy, sizeof(int)));
ValidateLength(totalLength);
return(ReadUntil(proxy, totalLength));
}
private void ReadChunk(ISocketProxy proxy)
{
AdjustCapacity();
int noOfBytesInChunk = proxy.Receive(data, ReadNoOfBytesReceived, data.Length - ReadNoOfBytesReceived, SocketFlags.None);
ValidateRead(noOfBytesInChunk);
ReadNoOfBytesReceived += noOfBytesInChunk;
}
private byte[] ReadUntil(ISocketProxy proxy, int totalLength)
{
while (ReadNoOfBytesReceived < totalLength)
{
ReadChunk(proxy);
}
return(ExtractReceivedData(totalLength));
}
private void _addClients(int n = 5)
{
var sockets = new ISocketProxy[n];
for (var i = 0; i < sockets.Length; i++)
{
sockets[i] = new MockSocketProxy();
}
foreach (var socket in sockets)
{
_cluster.Add(socket);
}
}
internal ZmqSocket(ISocketProxy socketProxy, IErrorProviderProxy errorProviderProxy)
{
if (socketProxy == null)
{
throw new ArgumentNullException("socketProxy");
}
if (errorProviderProxy == null)
{
throw new ArgumentNullException("errorProviderProxy");
}
this.proxy = socketProxy;
this.errorProvider = new ZmqErrorProvider(errorProviderProxy);
}
static void Main(string[] args)
{
Console.Title = "Client";
//create a new client.
socketProxy = new SocketProxy();
client = new ClientBase(socketProxy);
client.ConnectServer();
if (client.IsConnected) //if client connected begin to send.
{
client.SendLoop();
}
Console.ReadLine();
}
static void Main(string[] args)
{
Console.Title = "Server";
//dependency injection can be use for inject.
socketProxy = new SocketProxy();
server = new ServerBase(socketProxy);
server.Run();
if (server.IsBoundedServer)
{
server.BeginListen();
}
Console.ReadLine();
}
public void Start(Socket sck)
{
if (sck == null)
{
throw new ArgumentNullException(nameof(sck));
}
if (server == null)
{
throw new InvalidOperationException("Server not set: Please call the \"SetSocketServer\" Method and set it up.");
}
if (_onClose == null)
{
throw new InvalidOperationException("CloseHandler not set: Please call the \"SetCloseHandler\" Method and set it up.");
}
logger = server.service.loggerFactroy.GetLogger(GetType()) ??
throw new InvalidOperationException(
"\"ISocketSession.loggerFactory\" returned null : Unable to get Logger.");
_msgFilter = server.msgFilterFactory.Get() ??
throw new InvalidOperationException(
"\"ISocketSession.msgFilterFactory\" returned null : Unable to get MsgFilter.");
_socketProxy = CreateSocketProxy() ??
throw new InvalidOperationException("\"CreateSocketProxy\" Method returned null.");
int prevState = Interlocked.CompareExchange(ref _state, (int)ISocketSession.State.Running, (int)ISocketSession.State.None);
if (prevState != (int)ISocketSession.State.None)
{
throw new InvalidOperationException("ISocketSession state before startup is invalid.");
}
_socketProxy.onReceived = OnReceivedFromSocketProxy;
_socketProxy.onError = OnErrorFromSocketProxy;
_socketProxy.onClose = OnCloseFromSocketProxy;
_socketProxy.Start(sck, server.service.loggerFactroy.GetLogger(_socketProxy.GetType()));
behavior?.OnStarted(this);
}
public void StartServer(IPAddress ipAddress)
{
try
{
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 8300);
serverSocket.Bind(localEndPoint);
serverSocket.Listen(10);
Console.WriteLine("Waiting for clients to connect...");
while (true)
{
ISocketProxy clientSocket = serverSocket.Accept();
Individual normalPerson = new NormalPerson(new Person(clientSocket));
Thread myThread = new Thread(HandleLogin);
myThread.Start(normalPerson);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
/// <inheritdoc/>
public string SendReceive(string message)
{
string receivedMessage = string.Empty;
using (ISocketProxy socket = this.CreateSocket())
{
int numSocketReadTries = 0;
while (socket.Available < 1 && numSocketReadTries < MAX_SOCKET_READ_TRIES)
{
numSocketReadTries++;
Thread.Sleep(SOCKET_READ_SLEEP_TIME);
}
// Verify that the initial connection has data (handshake)
if (socket.Available > 0)
{
int bytes = 0;
byte[] handShakeSegment = new byte[12];
byte[] handShakeData = new byte[8];
// read 12 bytes of HandShake Segment and 8 bytes of HandShake data
bytes = socket.Receive(handShakeSegment, 0, 12);
bytes = socket.Receive(handShakeData, 0, 8);
byte initialSeed = 0;
byte[] encodedHandshake = this.EncodeData(handShakeData, initialSeed);
byte seed = encodedHandshake[7];
using (MemoryStream encodedMessage = this.CreateEncodedMessage(encodedHandshake, message, seed))
{
// send message to HNClient
socket.Send(encodedMessage.ToArray(), (int)encodedMessage.Length);
}
numSocketReadTries = 0;
while (socket.Available < 1 && numSocketReadTries < MAX_SOCKET_READ_TRIES)
{
numSocketReadTries++;
Thread.Sleep(SOCKET_READ_SLEEP_TIME);
}
// Receive the data
byte[] bytesReceived = new byte[12];
bytes = socket.Receive(bytesReceived, 0, 12);
if (bytesReceived.Length <= 0)
{
#pragma warning disable CA1303 // Do not pass literals as localized parameters
throw new InvalidDataException("Could not find entire message.");
#pragma warning restore CA1303 // Do not pass literals as localized parameters
}
// Read the message payload and attempt to load the message;
string headerIn = this.DecodeData(bytesReceived, seed);
int messageLength = int.Parse(headerIn.Substring(DATA_INDICATOR_LENGTH, LENGTH_INDICATOR_LENGTH - DATA_INDICATOR_LENGTH), System.Globalization.CultureInfo.InvariantCulture);
numSocketReadTries = 0;
while (socket.Available < messageLength)
{
if (numSocketReadTries < MAX_SOCKET_READ_TRIES)
{
numSocketReadTries++;
Thread.Sleep(SOCKET_READ_SLEEP_TIME);
}
else
{
#pragma warning disable CA1303 // Do not pass literals as localized parameters
throw new InvalidDataException("Could not find entire message.");
#pragma warning restore CA1303 // Do not pass literals as localized parameters
}
}
// Receive the HL7 Data
byte[] dataHL7in = new byte[messageLength];
socket.Receive(dataHL7in, 0, messageLength);
string hl7Message = this.DecodeData(dataHL7in, seed);
// Validate the hl7 message
int indexOfMSG = hl7Message.IndexOf(HEADER_INDICATOR, StringComparison.InvariantCulture);
if (indexOfMSG != -1)
{
// Read after the MSH segment.
receivedMessage = hl7Message.Substring(indexOfMSG) + "\r";
}
else
{
#pragma warning disable CA1303 // Do not pass literals as localized parameters
throw new InvalidDataException("Could not find MSG header");
#pragma warning restore CA1303 // Do not pass literals as localized parameters
}
}
}
return(receivedMessage);
}
public Person(string nom, ISocketProxy socket) : this(socket)
{
this.Name = nom;
}
public Person(ISocketProxy socket)
{
this.socket = socket;
this.buffer = new Buffer();
}
internal ReceiveSocket(ISocketProxy proxy, IErrorProviderProxy errorProviderProxy)
: base(proxy, errorProviderProxy)
{
}
internal SubscribeSocket(ISocketProxy proxy, IErrorProviderProxy errorProviderProxy)
: base(proxy, errorProviderProxy)
{
}
public Client(ISocketProxy socket)
{
_socket = socket;
}
public TestServer()
{
_server = new SocketProxy(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
}
internal SendSocket(ISocketProxy proxy, IErrorProviderProxy errorProviderProxy)
: base(proxy, errorProviderProxy)
{
}
public ClientBase(ISocketProxy socketProxy)
{
_socket = socketProxy;
}
public Server(ISocketProxy socket)
{
this.serverSocket = socket;
this.mainRoom = new Room();
}
internal DuplexSocket(ISocketProxy proxy, IErrorProviderProxy errorProviderProxy)
: base(proxy, errorProviderProxy)
{
}
public Server(ISocketProxy socket)
{
_socket = socket;
}
public UdpServerClient(ISocketProxy socket)
{
_socket = socket;
}
public ClientSocket(IPEndPoint endpoint, ISocketProxy socket)
{
IpEndpoint = endpoint;
Socket = socket;
}
public ServerBase(ISocketProxy socketProxy)
{
_socket = socketProxy;
_event = new AutoResetEvent(false);
_clients = new List <StateObject>();
}
public Client(ISocketProxy socket)
{
this.clientSocket = socket;
}
