public TestProgram(bool useMulticast)
{
IPEndPoint multicastEP = new IPEndPoint(IPAddress.Parse(multicastAddr), multicastPort);
IPEndPoint reflectorEP = new IPEndPoint(IPAddress.Parse(reflectorAddr), reflectorPort);
if (useMulticast)
{
listener = new UdpListener(multicastEP, 0);
sender = new UdpSender(multicastEP, 64);
}
else
{
// reflector
//listener = new UdpListener(multicastEP, reflectorEP, 0);
sender = new UdpSender(reflectorEP, 64);
}
Thread thread1 = new Thread(SendSomeStuff);
thread1.Start();
Thread thread2 = new Thread(ReceiveSomeStuff);
thread2.Start();
}
public IEnumerator SetReceiverThenSendTwice()
{
var count = 2;
var receivedCount = 0;
var port = 8888;
try
{
udpReceiver = new UdpReceiver(
IP.LocalIPAddressSync(),
port,
bytes =>
{
True(bytes.Length == 4);
receivedCount++;
}
);
// send udp data.
udpSender = new UdpSender(IP.LocalIPAddressSync(), port);
udpSender.Send(new byte[] { 1, 2, 3, 4 });
udpSender.Send(new byte[] { 1, 2, 3, 4 });
}
catch (Exception e)
{
Fail(e.ToString());
}
yield return(WaitUntil(
() => count == receivedCount,
() => { throw new TimeoutException("failed."); }
));
}
public SettingsForm(UdpReciever udpReciever, UdpSender udpSender)
{
InitializeComponent();
this.udpReciever = udpReciever;
this.udpSender = udpSender;
}
public static IServiceCollection AddJaegerTracing(
this IServiceCollection services,
Settings settings)
{
Guard.Argument(settings).NotNull();
Guard.Argument(settings.ServiceName !).NotNull().NotEmpty().NotWhiteSpace();
Guard.Argument(settings.Host).NotNull().NotEmpty().NotWhiteSpace();
Guard.Argument(settings.SamplingRate).InRange(0, double.MaxValue);
var sender = new UdpSender(settings.Host, settings.Port, maxPacketSize: 0);
var reporter = new RemoteReporter.Builder()
.WithSender(sender)
.Build();
ISampler sampler = settings.SamplingRate switch
{
double d when d >= 1 => new ConstSampler(sample: true),
double d when d <= 0 => new ConstSampler(sample: false),
_ => new ProbabilisticSampler(samplingRate: settings.SamplingRate),
};
var tracer = new Tracer.Builder(settings.ServiceName !)
.WithReporter(reporter)
.WithSampler(sampler)
.Build();
return(services
.AddOpenTracing()
.AddSingleton <ITracer>(tracer));
}
public void CommLayer_UDP_GetSender()
{
UdpSender s = new UdpSender("127.0.0.1", 16000);
Assert.AreEqual(16000, s.GetPort(), "Sender ports should return 16000");
s.CloseConnection();
}
public void CommLayer_UDP_SendBytesValid()
{
List <string> listDataIn = new List <string> {
"data1", "data2", "foobar"
};
List <byte[]> listData = new List <byte[]>();
foreach (string str in listDataIn)
{
listData.Add(Encoding.ASCII.GetBytes(str));
}
UdpReceiver r = new UdpReceiver(15000);
UdpSender s = new UdpSender("127.0.0.1", 15000);
r.StartListen();
s.SendData(listData);
ManualResetEvent mre = new ManualResetEvent(false);
mre.WaitOne(1000);
List <Byte[]> ret = r.GetBytesData();
Assert.AreEqual(listDataIn.Count, ret.Count, "We should have received the same number of items like sent.");
for (int i = 0; i < ret.Count; i++)
{
Assert.AreEqual(Encoding.ASCII.GetString(ret[i]), listDataIn[i], "Data received should be the same.");
}
r.CloseConnection();
s.CloseConnection();
}
public IEnumerator SetReceiverThenSendManyTimes()
{
var count = 1000;
var receivedCount = 0;
var port = 8888;
udpReceiver = new UdpReceiver(
IP.LocalIPAddressSync(),
port,
bytes =>
{
True(bytes.Length == 4);
receivedCount++;
}
);
// send udp data.
udpSender = new UdpSender(IP.LocalIPAddressSync(), port);
for (var i = 0; i < count; i++)
{
udpSender.Send(new byte[] { 1, 2, 3, 4 });
}
yield return(WaitUntil(
() => count == receivedCount,
() => { throw new TimeoutException("failed."); }
));
}
private void OnUdpMessageReceived(UdpReceiver sender, UdpMessageReceivedEventArgs e)
{
if (e.Content == "ml.festival.defectively.scan")
{
UdpSender.SendMessage("ml.festival.defectively.scanResponse:42000", e.RemoteEndPoint.Address.ToString(), 52001);
}
}
public void CommLayer_UDP_SendWithDelay()
{
List <string> listData = new List <string> {
"data1", "data2", "foobar"
};
List <string> listData2 = new List <string> {
"data3", "dataX", "bloop"
};
UdpSender s = new UdpSender("127.0.0.1", 15000);
s.SendData(listData);
ManualResetEvent mre = new ManualResetEvent(false);
mre.WaitOne(1000);
UdpReceiver r = new UdpReceiver(15000);
s.SendData(listData2);
r.StartListen();
mre.WaitOne(1000);
List <Byte[]> ret = r.GetBytesData();
Assert.AreEqual(listData2.Count, ret.Count, "We should have received the same number of items like sent the second time.");
for (int i = 0; i < ret.Count; i++)
{
Assert.AreEqual(Encoding.ASCII.GetString(ret[i]), listData2[i], "Data received should be the same.");
}
r.CloseConnection();
s.CloseConnection();
}
private async Task Send(byte[] data, Player player)
{
if (player.IPTo != null)
{
await UdpSender.SendAsync(data, data.Length, player.IPTo);
}
}
public static UdpSender NewUnicast(string _address, int port)
{
IPAddress address = IPAddress.Parse(_address);
/*IPAddress any_address;
* // IPv4
* if (address.AddressFamily == AddressFamily.InterNetwork)
* {
* any_address = IPAddress.Any;
* }
* // IPv6
* else if (address.AddressFamily == AddressFamily.InterNetworkV6)
* {
* any_address = IPAddress.IPv6Any;
* }
* else
* {
* throw new System.Exception("Address (" + _address + ") must be either IPv4 or IPv6");
* }
*/
UdpSender ans = new UdpSender();
try
{
ans.Client = new UdpClient(address.AddressFamily);
ans.Endpoint = new IPEndPoint(address, port);
}
catch (System.Exception ex)
{
Console.WriteLine("UdpSender error=" + ex.Message);
}
return(ans);
}
public void TestUdpHost()
{
// Only accept UDP connections from specified host
ushort port = TestBase.MakePort(48000, 49000);
string desc;
using (var sender = new UdpSender("127.0.0.1", port, "Hello"))
{
Run(new Params {
{ "Protocol", "udp" }, { "Host", "127.0.0.2" }, { "Timeout", "1000" }, { "Interface", "127.0.0.1" }, { "Port", port.ToString() }
}, false);
}
Assert.Null(faults);
using (var sender = new UdpSender("127.0.0.1", port, "Hello"))
{
desc = string.Format("Received 5 bytes from '{0}'.", sender.Client.LocalEndPoint);
Run(new Params {
{ "Protocol", "udp" }, { "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"]);
}
HeartbeatServerConsole(String addr, int port)
{
IPAddress ipaddr = IPAddress.Parse(addr);
IPEndPoint iep = new IPEndPoint(ipaddr, port);
udpSender = new UdpSender(iep, 32);
}
public void TestMulticast()
{
IPAddress addr;
using (Socket s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
s.Connect(new IPEndPoint(IPAddress.Parse("1.1.1.1"), 80));
addr = ((IPEndPoint)s.LocalEndPoint).Address;
}
// Support 'Host' of 234.5.6.7
ushort port = TestBase.MakePort(46000, 47000);
string host = "234.5.6.7";
string desc;
using (var sender = new UdpSender(addr, host, port, "Hello"))
{
desc = string.Format("Received 5 bytes from '{0}'.", sender.Client.LocalEndPoint);
Run(new Params {
{ "Protocol", "udp" }, { "Interface", addr.ToString() }, { "Host", host }, { "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"]);
}
void OnEnable()
{
m_sender = new UdpSender(server, port);
m_udp.StartConnection(listenerPort);
// m_udp.SetDestination(server, port);
m_thread.Start(m_udp, OnReceiveData);
m_acknowledged = false;
}
/// <summary>
/// Notica a las demas cuentas que el corredor puede comer perseguidores
/// </summary>
public void NotificarCorredorPuedeComerJugadores()
{
EventoEnJuego CorredorPuedeComerCorredores = new EventoEnJuego();
CorredorPuedeComerCorredores.SeInicioTiempoDeMatar(CuentaEnSesion.NombreUsuario, IdDeMiSala);
UdpSender EnviadorDePauetesUdp = new UdpSender(DireccionIpDelServidor, PUERTO_ENVIO_UDP1, PUERTO_ENVIO_UDP2);
EnviadorDePauetesUdp.EnviarPaquete(CorredorPuedeComerCorredores);
}
/// <summary>
/// Notifica a los demas jugadores que el jugador mato a otro
/// </summary>
/// <param name="nombreUsuario">String</param>
/// <param name="NumeroVidas">String</param>
public void NotificarMuerteJugador(String nombreUsuario, int NumeroVidas)
{
EventoEnJuego MuerteDeJugador = new EventoEnJuego();
MuerteDeJugador.EventoEnJuegoMuerteJugador(CuentaEnSesion.NombreUsuario, IdDeMiSala, nombreUsuario, NumeroVidas);
UdpSender EnviadorDePaquetesUDP = new UdpSender(DireccionIpDelServidor, PUERTO_ENVIO_UDP1, PUERTO_ENVIO_UDP2);
EnviadorDePaquetesUDP.EnviarPaquete(MuerteDeJugador);
}
private void UdpSenderBtn_Click(object sender, RoutedEventArgs e)
{
Thread t = new Thread(() => {
UdpSender udpSender = new UdpSender();
udpSender.SenderStart(new string[] { "-p", "9400", "-h", "localhost" });
});
t.SetApartmentState(ApartmentState.MTA);
t.Start();
}
public ScanWindow()
{
InitializeComponent();
receiver.UdpMessageReceived += OnUdpMessageReceived;
UdpSender.Broadcast("ml.festival.defectively.scan", 52000);
new Task(async() => { await receiver.ReceiveAsync(); }).Start();
}
/// <summary>
/// Envia a las demas cuentas el movimiento realizado por el jugador
/// </summary>
/// <param name="x">float</param>
/// <param name="y">float</param>
/// <param name="movimientoX">float</param>
/// <param name="movimientoY">float</param>
public void EnviarMovimiento(float x, float y, float movimientoX, float movimientoY)
{
EventoEnJuego eventoEnJuego = new EventoEnJuego();
eventoEnJuego.EventoEnJuegoMovimientoJugador(CuentaEnSesion.NombreUsuario, IdDeMiSala, CuentaEnSesion.NombreUsuario,
x, y, movimientoX, movimientoY);
UdpSender enviadorDePaquetesUDP = new UdpSender(DireccionIpDelServidor, PUERTO_ENVIO_UDP1, PUERTO_ENVIO_UDP2);
enviadorDePaquetesUDP.EnviarPaquete(eventoEnJuego);
}
public void Dispose() {
if (!m_Disposed) {
Stop();
if (m_UdpSender != null) {
m_UdpSender.Dispose();
m_UdpSender = null;
}
m_Disposed = true;
}
}
/// <summary>
/// Close and stop sending messages.
/// </summary>
public void Close()
{
if (_pingCoroutine != null)
{
StopCoroutine(_pingCoroutine);
_pingCoroutine = null;
}
_remoteStatus = OscRemoteStatus.Unknown;
_sender = null;
_wasClosedOnDisable = false;
}
public void ReadyToPlay(List <IPEndPoint> iPEnds)
{
UdpSender sender = new UdpSender();
UdpMessage messageToA = new UdpMessage("BPlayToARec", user.UserName);
sender.Send(iPEnds[2], udpSender.GetLocalIP(), "17720", messageToA.ToString());
UdpMessage messageToServer = new UdpMessage("BPlayToARecHoleOpened:" + otherName, user.UserName);
sender.Send("152.136.73.240", "17722", udpSender.GetLocalIP(), "17721", messageToServer.ToString());
voiceReceiver.Start();
}
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");
}
public P2PClient(Int16 localPort, UIComponent ui)
{
try {
_client = new UdpClient(localPort);
_receiver = new UdpReceiver(_client, 200);
_sender = new UdpSender(_client);
P2PClient.ui = ui;
}
catch (Exception ex) {
System.Console.WriteLine(ex.Message);
}
}
public void Dispose()
{
if (!m_Disposed)
{
Stop();
if (m_UdpSender != null)
{
m_UdpSender.Dispose();
m_UdpSender = null;
}
m_Disposed = true;
}
}
public void TestConnNoFault()
{
// receive connection, FaultOnSuccess = true results in no fault
ushort port = TestBase.MakePort(44000, 45000);
using (var sender = new UdpSender("127.0.0.1", port, "Hello"))
{
Run(new Params {
{ "FaultOnSuccess", "true" }, { "Protocol", "udp" }, { "Interface", "127.0.0.1" }, { "Port", port.ToString() }
}, false);
}
Assert.Null(faults);
}
static void Main(string[] args)
{
var sender = new UdpSender();
Logger.Enable(Loggers.ConsoleLogger);
bool stop = false;
do
{
string input = Console.ReadLine();
sender.SendAsync(input);
stop = input == "s";
} while (!stop);
}
public CommChannel(IPEndPoint ep, bool willSend, bool willReceive)
{
SetupPacketizer();
SetupBufferChunks();
if (willSend)
fSender = new UdpSender(ep, 2);
if (willReceive)
{
fReceiver = new UdpReceiver(ep, NetworkTimeout);
fReceiver.AsyncReceiveFrom(fChunks, this.ReceiveChunk);
}
}
void OnEnable()
{
#if UNITY_IOS && !UNITY_EDITOR
var faceManager = FindObjectOfType <ARFaceManager>();
if (faceManager != null)
{
m_ARKitFaceSubsystem = (ARKitFaceSubsystem)faceManager.subsystem;
}
udpSender = FindObjectOfType <UdpSender>();
#endif
UpdateVisibility();
m_Face.updated += OnUpdated;
ARSession.stateChanged += OnSystemStateChanged;
}
public HeartbeatServer(String addr, int port, uint cookie, int period, ushort ttl) {
m_Period = period;
m_Thread = null;
m_Disposed = false;
//Set up the send buffer
byte[] buffer = new byte[sizeof(uint)];
m_PacketBuffer = new BufferChunk(buffer);
m_PacketBuffer.SetUInt32(0, cookie);
//Create the Sender
IPAddress ipaddr = IPAddress.Parse(addr);
m_IpEp = new IPEndPoint(ipaddr, port);
m_UdpSender = new UdpSender(m_IpEp, ttl);
}
void OnEnable()
{
dmxToSend.DmxData = new byte[512];
if (!useBroadcast)
{
remote = new IPEndPoint(UdpSender.FindFromHostName(remoteIP), Port);
}
else
{
remote = new IPEndPoint(IPAddress.Broadcast, Port);
}
CreateInitialize();
CreateUpdate();
}
public void CommLayer_UDP_BadIPFormat()
{
UdpSender s;
try
{
s = new UdpSender("127.6666.s.4536ss", 15000);
s.CloseConnection();
}
catch (FormatException e)
{
this.Log().Debug("Expected exception" + Environment.NewLine + e.ToString());
// expected
}
}
public RTPPlayer(string host, int port, VideoCache vc)
{
us = new UdpSender(host, port);
this.vc = vc;
}
HeartbeatServerConsole(String addr, int port)
{
IPAddress ipaddr = IPAddress.Parse(addr);
IPEndPoint iep = new IPEndPoint(ipaddr, port);
udpSender = new UdpSender(iep, 32);
}
