private void OnConnected(TcpSender sender)
{
Debug.WriteLine($"connected to server {sender.RemoteEndPoint}");
SetSendButton(true);
//AppendMessage(sender.LocalEndPoint.ToString(), "join(you).", MessageType.Join, true);
}
public void TestTcpHost()
{
// Only accept TCP connections from specified host
ushort port = TestBase.MakePort(47000, 48000);
string desc;
using (var sender = new TcpSender("127.0.0.1", port, "Hello"))
{
Run(new Params {
{ "Host", "127.0.0.2" }, { "Timeout", "1000" }, { "Interface", "127.0.0.1" }, { "Port", port.ToString() }
}, false);
}
Assert.Null(faults);
using (var sender = new TcpSender("127.0.0.1", port, "Hello"))
{
desc = string.Format("Received 5 bytes from '{0}'.", sender.localEP);
Run(new Params {
{ "Host", "127.0.0.1" }, { "Timeout", "1000" }, { "Interface", "127.0.0.1" }, { "Port", port.ToString() }
}, true);
}
Assert.NotNull(faults);
Assert.AreEqual(1, faults.Length);
Assert.AreEqual("SocketMonitor", faults[0].detectionSource);
Assert.AreEqual(FaultType.Fault, faults[0].type);
Assert.AreEqual(desc, faults[0].description);
Assert.True(faults[0].collectedData.ContainsKey("Response"));
Assert.AreEqual(Encoding.ASCII.GetBytes("Hello"), faults[0].collectedData["Response"]);
}
public override void Dispose()
{
Logger.Debug("Dispose SenderManager");
TcpSender?.Dispose();
UdpSender?.Dispose();
}
private static RequestSender InitTcpSender(Settings settings)
{
string ip = settings.SERVER_IP;
TcpSender tcpClient;
try
{
tcpClient = new TcpSender(ip, settings.CONTROL_TCP_PORT,
settings.RESPOND_TIMEOUT);
}
catch
{
MessageBox.Show("Nepodařilo se zinicializovat síťovou komunikaci, program bude ukončen.", "Chyba", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
var sender = new RequestSender(tcpClient);
sender.NetProblem += ProgramError;
sender.UnrecognizedResponse += ProgramError;
sender.CryptoError += ProgramError;
sender.Unauthorized += ProgramError;
sender.AccessDenied += ProgramError;
sender.CannotExecute += ProgramError;
sender.InvalidResponse += ProgramError;
MasterContainer.AddService(sender);
return(sender);
}
public void Setup(IPEndPoint clientinfo, IPEndPoint serverinfo)
{
this._sender = new TcpSender(clientinfo, serverinfo);
this._fileSender = new FileSender(this._sender);
this._directoryRequester = new DirectoryResquestSender(this._sender);
this._sender.Connect();
}
// Use this for initialization
void Start()
{
tcp_sender_ = GetComponent <TcpSender>();
serializer_ = GetComponent <Serializer>();
// send camera tf in 0 second every pub_frequency_ second
InvokeRepeating("SendCamTransform", 0.0f, pub_frequency_);
}
// Use this for initialization
void Start()
{
tcp_sender_ = GetComponent <TcpSender>();
sensor_ = GetComponent <RawSensorReader>();
// send camera tf in 0 second every pub_frequency_ second
InvokeRepeating("SendSensorStream", 0.0f, pub_frequency_);
}
private void OnClosed(TcpSender sender)
{
Debug.WriteLine($"disconnect from server {sender.RemoteEndPoint}");
//AppendMessage(sender.LocalEndPoint.ToString(), "leave(you).", MessageType.Leave, true);
SetOnlineNumber(0);
SetSendButton(false);
}
public TcpMessageSender(string hostname, int port, bool useOctetCounting, TcpSenderSettings senderSettings)
{
_useOctetCounting = useOctetCounting;
_tcpSender = TcpSender.Initialize(
hostname,
port,
senderSettings
);
}
private void Send(TcpSender sender, byte[] bytes)
{
foreach (TcpSender item in server.Clients)
{
if (item.Guid != sender.Guid)
{
item.Send(bytes);
}
}
}
public SenderManager(string multicastHostint, int tcpRemotePort, int udpRemotePort)
{
//Logging.Logger.InitLogger();
Logger = Logging.Log;
Logger.Debug("Creating SenderManager");
TcpSender = new TcpSender(tcpRemotePort);
UdpSender = new UdpSender(multicastHostint, udpRemotePort);
Logger.Debug("Created SenderManager");
}
private void SendMessages()
{
portResultsFromSender = new Dictionary <int, int>();
BackgroundWorker bw = new BackgroundWorker {
WorkerReportsProgress = true
};
int numMessagesToSend = int.Parse(txtNumToSend.Text);
bw.DoWork += new DoWorkEventHandler(delegate(object o, DoWorkEventArgs args)
{
BackgroundWorker b = o as BackgroundWorker;
var tcpSender = new TcpSender {
DestinationServer = txtEndpoint.Text.Trim(), DestinationPort = int.Parse(txtPort.Text.Trim())
};
for (int i = 1; i <= numMessagesToSend; i++)
{
var response = tcpSender.SendHL7(DefaultHL7Message);
if (portResultsFromSender.ContainsKey(response.Port) == false)
{
portResultsFromSender.Add(response.Port, 1);
}
else
{
portResultsFromSender[response.Port] += 1;
}
b.ReportProgress((int)((double)i / numMessagesToSend * 100));
}
});
// what to do when progress changed (update the progress bar for example)
bw.ProgressChanged += new ProgressChangedEventHandler(delegate(object o, ProgressChangedEventArgs args)
{
lblProgress.Text = string.Format("{0}% Completed", args.ProgressPercentage);
});
// what to do when worker completes its task (notify the user)
bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(delegate(object o, RunWorkerCompletedEventArgs args)
{
label1.Text = "Finished!";
portsResults.Visible = true;
foreach (var item in portResultsFromSender.OrderByDescending(x => x.Value))
{
portsResults.Items.Add(string.Format("Port {0}: {1} messages", item.Key, item.Value));
}
});
bw.RunWorkerAsync();
}
public MetricTcpSender(
string hostname,
int port,
TcpSenderSettings senderSettings)
{
_tcpSender = TcpSender.Initialize(
hostname,
port,
senderSettings
);
}
private void OnData(TcpSender sender, byte[] bytes)
{
byte[] tmp = sender.Guid.ToByteArray();
byte[] buffer = new byte[tmp.Length + bytes.Length + 3];
buffer[0] = 0x02;
buffer[tmp.Length + 1] = 0x4D;
buffer[buffer.Length - 1] = 0x03;
Buffer.BlockCopy(tmp, 0, buffer, 1, tmp.Length);
Buffer.BlockCopy(bytes, 0, buffer, tmp.Length + 2, bytes.Length);
Send(sender, buffer);
}
private void OnData(TcpSender sender, byte[] bytes)
{
length = bytes.Length;
if (bytes[0] == 0x02)
{
buffer = bytes;
}
else
{
byte[] tmp = buffer;
buffer = new byte[tmp.Length + length];
Buffer.BlockCopy(tmp, 0, buffer, 0, tmp.Length);
Buffer.BlockCopy(bytes, 0, buffer, tmp.Length, length);
}
if (buffer.Length < 19 || bytes[length - 1] != 0x03)
{
return;
}
byte[] gb = new byte[16];
Buffer.BlockCopy(buffer, 1, gb, 0, 16);
Guid guid = new Guid(gb);
isSelf = guid == sender.Guid;
byte cmd = buffer[17];
switch (cmd)
{
case 0x4F: //O
onlineNumber = BitConverter.ToInt32(buffer, 18);
SetOnlineNumber(onlineNumber);
AppendMessage(guid.ToString(), "join", MessageType.Join, isSelf);
break;
case 0x4D: //M
{
message = client.Encoding.GetString(buffer, 18, buffer.Length - 19);
AppendMessage(guid.ToString(), message, MessageType.Chat, isSelf);
}
break;
case 0x43: //C
onlineNumber = BitConverter.ToInt32(buffer, 18);
SetOnlineNumber(onlineNumber);
AppendMessage(guid.ToString(), "leave", MessageType.Leave, isSelf);
break;
}
}
public void OnSend(object sender, EventDataArg <string> e)
{
Logger.Info($"Send to {e.HostInfo.Host} via {e.HostInfo.Protocol} message {e.Data}");
switch (e.HostInfo.Protocol)
{
case UdpSender.Name:
UdpSender.SendAsync(e.HostInfo.Host, e.Data);
break;
case TcpSender.Name:
TcpSender.SendAsync(e.HostInfo.Host, e.Data);
break;
default:
Logger.Error($"Unknow protocol {e.HostInfo.Protocol} for {e.HostInfo}, message {e.Data}");
break;
}
}
public TcpSendResults SendMessages(SendHL7ViewModel model, TcpSender tcpSender)
{
int sendMsgCounter = 0;
Stopwatch s = new Stopwatch();
try
{
s.Start();
for (sendMsgCounter = 0; sendMsgCounter < model.NumMessages; sendMsgCounter++)
{
tcpSender.SendHL7(model.HL7MessageToSend);
}
s.Stop();
return new TcpSendResults { TimeElapsed = s.Elapsed, NumberMsgsSent = sendMsgCounter };
}
catch (Exception e)
{
return new TcpSendResults { TimeElapsed = s.Elapsed, NumberMsgsSent = sendMsgCounter, ExceptionDuringSend = e.Message };
}
}
private void OnClosed(TcpSender sender)
{
AppendMessage(sender.RemoteEndPoint.ToString(), sender.RemoteEndPoint.ToString() + " leave.", MessageType.Leave);
clientNumber = server.Clients.Count;
SetOnlineNumber(clientNumber);
byte[] tmp = sender.Guid.ToByteArray();
byte[] buffer = new byte[tmp.Length + 7];
buffer[0] = 0x02;
buffer[buffer.Length - 6] = 0x43;
buffer[buffer.Length - 5] = (byte)(clientNumber & 0xff);
buffer[buffer.Length - 4] = (byte)((clientNumber >> 8) & 0xff);
buffer[buffer.Length - 3] = (byte)((clientNumber >> 16) & 0xff);
buffer[buffer.Length - 2] = (byte)((clientNumber >> 24) & 0xff);
buffer[buffer.Length - 1] = 0x03;
Buffer.BlockCopy(tmp, 0, buffer, 1, tmp.Length);
Send(sender, buffer);
}
public void TestTcp6()
{
ushort port = TestBase.MakePort(52000, 53000);
string desc;
using (var sender = new TcpSender("::1", port, "Hello"))
{
desc = string.Format("Received 5 bytes from '{0}'.", sender.localEP);
Run(new Params {
{ "Interface", "::1" }, { "Port", port.ToString() }
}, true);
}
Assert.NotNull(faults);
Assert.AreEqual(1, faults.Length);
Assert.AreEqual("SocketMonitor", faults[0].detectionSource);
Assert.AreEqual(FaultType.Fault, faults[0].type);
Assert.AreEqual(desc, faults[0].description);
Assert.True(faults[0].collectedData.ContainsKey("Response"));
Assert.AreEqual(Encoding.ASCII.GetBytes("Hello"), faults[0].collectedData["Response"]);
}
static int Main(string[] args)
{
Console.Write("Enter the IP address: ");
string ipAddress = Console.ReadLine();
Console.Write("Enter port: ");
int port;
try
{
port = Convert.ToInt32(Console.ReadLine());
}
catch (FormatException)
{
Console.WriteLine("Error: need to enter a number!");
return(1);
}
try
{
var tcpSender = new TcpSender();
tcpSender.Start(ipAddress, port);
Console.Write("Enter path to file: ");
string pathToFile = Console.ReadLine();
tcpSender.SendFile(pathToFile);
tcpSender.Stop();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("Stop!");
Console.ReadLine();
return(0);
}
public TcpSendResults SendMessages(SendHL7ViewModel model, TcpSender tcpSender)
{
int sendMsgCounter = 0;
Stopwatch s = new Stopwatch();
try
{
s.Start();
for (sendMsgCounter = 0; sendMsgCounter < model.NumMessages; sendMsgCounter++)
{
tcpSender.SendHL7(model.HL7MessageToSend);
}
s.Stop();
return(new TcpSendResults {
TimeElapsed = s.Elapsed, NumberMsgsSent = sendMsgCounter
});
}
catch (Exception e)
{
return(new TcpSendResults {
TimeElapsed = s.Elapsed, NumberMsgsSent = sendMsgCounter, ExceptionDuringSend = e.Message
});
}
}
protected TcpModule()
{
sender = TcpConnection.sender;
TcpConnection.listener.OnMessageRecived += Listener_OnMessageRecived;
}
internal void PrepareSending()
{
sender = new TcpSender(stream);
sender.Start();
StartCoroutine(sender.WaitFor());
}
public RequestSender(TcpSender client)
{
this.client = client;
formatter = new NetFormatter();
}
private void OnException(TcpSender sender, Exception exception)
{
Debug.WriteLine($"{sender.RemoteEndPoint.ToString()} throw exception : {exception.Message},TargetSite : {exception.TargetSite}");
}
