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();
}
protected override void OnStart(string[] args)
{
var listenPort = 20777;
var hostAddress = "localhost";
var hostPort = 8080;
if (args.Length > 0)
{
int.TryParse(args[0], out listenPort);
}
if (args.Length > 1)
{
hostAddress = args[1];
}
if (args.Length > 2)
{
int.TryParse(args[2], out hostPort);
}
WebApp.Start($"http://{hostAddress}:{hostPort}");
_udpListener = new UdpListener(listenPort);
_udpListener.DataReceived += ((sender, data) => {
var packet = new UdpPacket(data);
var context = GlobalHost.ConnectionManager.GetHubContext <TelemetryHub>();
context.Clients.All.Send(packet);
});
_udpListener.StartListening();
}
protected override TransportMessage NewTransport(string uri, Resources resources)
{
UdpListener udpListener = resources.Get(UDP_LISTENER) as UdpListener;
IPEndPoint ipEndPoint = resources.Get(SOCKET_ADDRESS) as IPEndPoint;
URL url = new URL(uri);
TransportPacket transportPacket = null;
if (udpListener != null)
{
transportPacket = new UdpConnection(ipEndPoint, udpListener);
}
else
{
transportPacket = new UdpConnection(url);
}
TransportMessage transportMessage = new Messagizer(transportPacket, url, resources);
transportMessage = AddFilters(transportMessage, url, resources);
ValueFactory vf = (ValueFactory)resources.Get(TransportConsts.VALUE_FACTORY);
vf.LockDynamicTypes();
return(transportMessage);
}
internal override bool SendUdpBuffer(EndPoint remoteEndPoint, MessageBuffer message, Action <int, SocketError> completed)
{
SocketAsyncEventArgs args = ObjectCache.GetSocketAsyncEventArgs();
args.BufferList = null;
args.UserToken = new UdpSendOperation {
callback = completed, message = message
};
args.SetBuffer(message.Buffer, message.Offset, message.Count);
args.RemoteEndPoint = remoteEndPoint;
args.Completed += UdpSendCompleted;
bool completingAsync;
try
{
completingAsync = UdpListener.SendToAsync(args);
}
catch (Exception e)
{
Logger.Warning("UDP send failed as an exception was thrown.", e);
return(false);
}
if (!completingAsync)
{
UdpSendCompleted(this, args);
}
return(true);
}
public void Open(int listenPort, int broadcastPort)
{
port = listenPort;
this.broadcastPort = broadcastPort;
udpListener = new UdpListener(listenPort);
udpListener.RomoteIP += new UdpListener.RomoteIPEventHandler(udpListener_RomoteIP);
}
public StatsDMetricsTests(ITestOutputHelper output) : base(output)
{
_listener = new UdpListener("127.0.0.1", _port);
_client = new StatsDMetricsClient(new StatsDMetricsClientOptions {
ServerName = "127.0.0.1", Port = _port, Prefix = "test"
});
}
private void Init(DeviceConfigurationAdapter deviceConfig)
{
_deviceProxy = new DeviceProxy(deviceConfig);
_udpListener = new UdpListener(deviceConfig.UdpPort, SendMessage);
_webSocketClient = new WebSocketClient(deviceConfig.WebSocketClientConfig.ServerUrl, ReceiveMessage);
_healthThread = new HealthThread(CheckServerConnection, ReopenServerConnection);
}
static void Main(string[] args)
{
UdpListener listener = new UdpListener(new IPEndPoint(IPAddress.Parse("192.168.0.6"), 15000));
DhtEngine engine = new DhtEngine(listener);
byte[] nodes = null;
if (File.Exists("mynodes"))
nodes = File.ReadAllBytes("mynodes");
listener.Start();
engine.PeersFound += delegate(object o, PeersFoundEventArgs e) {
Console.WriteLine("I FOUND PEERS: {0}", e.Peers.Count);
engine.Start(nodes);
Random random = new Random(5);
byte[] b = new byte[20];
lock (random)
random.NextBytes(b);
while(Console.ReadLine() != "q")
{
for (int i = 0; i < 30; i++)
{
Console.WriteLine("Waiting: {0} seconds left", (30 - i));
System.Threading.Thread.Sleep(1000);
}
// Get some peers for the torrent
engine.GetPeers(b);
random.NextBytes(b);
}
File.WriteAllBytes("mynodes", engine.SaveNodes());
}
}
/// <summary>
/// Receives incoming data in a loop running in its own thread.
/// </summary>
/// <param name="ipEndPoint"></param>
/// <param name="trace"></param>
/// <exception cref="UdpSocketException">Thrown when socket cannot be bound to endpoint</exception>
public ListenerBase(IpEndpoint ipEndPoint, ITrace trace)
{
_ipEndPoint = ipEndPoint;
_trace = trace;
_listener = new UdpListener(ipEndPoint);
_messageLoop = new MessageLoop <UdpListener>(_listener, trace, Operation, StopOperation);
}
public MainWindow()
{
InitializeComponent();
var r = new Random();
_port = r.Next(1500, 2000);
_id = Guid.NewGuid();
_sessions = new Dictionary <IPEndPoint, Tuple <Peer, PascalMessageHandler> >();
_listener = new TcpListener(_port);
_comunicationManager = new CommunicationManager(_listener);
_comunicationManager.ConnectionClosed += ChatOnMemberDisconnected;
_comunicationManager.PeerConnected += ChatOnMemberConnected;
_comunicationManager.ConnectionFailed += ChatOnMemberConnectionFailure;
_comunicationManager.PeerDataReceived += OnPeerDataReceived;
_listener.Start();
_discovery = new UdpListener(3000);
_discovery.UdpPacketReceived += DiscoveryOnUdpPacketReceived;
_discovery.Start();
using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
socket.EnableBroadcast = true;
var group = new IPEndPoint(IPAddress.Broadcast, 3000);
var hi = Encoding.ASCII.GetBytes("Hi Peer2Net node here:" + _id + ":127.0.0.1:" + _port);
socket.SendTo(hi, group);
socket.Close();
}
}
/// <summary>
/// Main method
/// </summary>
/// <param name="args">array of arguments</param>
public static void Main(string[] args)
{
// create a new server
using (var server = new UdpListener())
{
// start listening for messages and copy the messages back to the client
// execute only when message received
while (true)
{
var received = server.Receive().Result;
Console.WriteLine("Sender:" + received.Sender + " " + "Message:" + received.Message);
string file = Path.Combine(Constants.VolumePath, received.Message);
if (IsExecuteCompleted(file))
{
server.Reply("Success", received.Sender);
}
else
{
server.Reply("Failure", received.Sender);
}
Console.WriteLine("Application installed successfully!");
}
}
}
protected override void InitUIOnShown()
{
HintProvider.WaitingDone(Application.ProductName);
base.InitUIOnShown();
this.pnlButtom.Visible = false;
this.btnMin.Visible = true;
ControlUtilityTool.SetControlDefaultFont(this.lblCaption, 15, FontStyle.Bold);
//this.lblCaption.Text = "网络设备参数设置工具";
string strVersion = string.Format("V{0}", StrUtils.GetFileVersion(Path.Combine(Application.StartupPath, "ParamsSettingTool.exe")));
title = "网络设备参数设置工具" + "(" + strVersion + ")";
this.lblCaption.Text = title;
f_UserControls = new Dictionary <string, GeneralUserControl>();
//启动Udp监听
int udpPort = StrUtils.StrToIntDef(AppXmlConfig.Singleton[AppXmlConfig.UDP_SOURCE_PORT].ToString(), AppConst.UDP_SOURCE_PORT);
f_UdpListener = new UdpListener(udpPort);
string errMsg = string.Empty;
if (!f_UdpListener.StartUdp(ref errMsg))
{
HintProvider.ShowAutoCloseDialog(this, string.Format("启动Udp监听失败，错误：{0}", errMsg));
}
AppXmlConfig.Singleton.Save();
//暂时无云对讲设备
this.nbItemCloudIntercom.Visible = false;
}
public StatsDMetricsTests(ITestOutputHelper output)
{
_listener = new UdpListener("127.0.0.1", _port);
_client = new StatsDMetricsClient("127.0.0.1", _port, "test");
_writer = new TestOutputWriter(output);
}
public void SendToAllClients(byte[] request)
{
foreach (UDPEndPoint client in Clients)
{
UdpListener.Send(request, request.Length, client.Endpoint);
}
}
private static void Listen2()
{
var stateReceiver = new UdpListener(8890);
stateReceiver.DatagramReceived += StateReceiver_DatagramReceived;
stateReceiver.Start();
try
{
Console.WriteLine($"listening on port 8890");
//var videoReceiver = new UdpReceiver(11111);
//videoReceiver.DatagramReceived += VideoReceiver_DatagramReceived;
//videoReceiver.Start();
//Console.WriteLine($"listening on port 11111");
//if (_stream != null)
//{
// _stream.Close();
//}
//while (true)
//{
// await Task.Yield();
//}
Console.WriteLine("==============================================");
Console.WriteLine("press any key to stop");
Console.WriteLine("==============================================");
Console.WriteLine();
Console.ReadKey();
}
finally
{
stateReceiver.Stop();
}
}
private void UDPReceiveCallback(IAsyncResult result)
{
IPEndPoint clientEndPoint = new IPEndPoint(IPAddress.Any, 0);
byte[] data = UdpListener.EndReceive(result, ref clientEndPoint);
UdpListener.BeginReceive(UDPReceiveCallback, null);
if (data.Length < 4)
{
return;
}
using (Packet packet = new Packet(data)) {
int clientId = packet.ReadInt();
if (clientId == 0)
{
return;
}
if (Clients[clientId].Udp.EndPoint == null)
{
Clients[clientId].Udp.Connect(clientEndPoint);
OnClientConnected?.Invoke(this, new ClientEventArgs(Clients[clientId], Protocol.UDP));
return;
}
if (Clients[clientId].Udp.EndPoint.ToString() == clientEndPoint.ToString())
{
Clients[clientId].Udp.HandleData(packet);
}
}
}
public int Action()
{
UdpListener lister = new UdpListener()
{
IpAddress = SenderIpAddress,
PortNo = SenderPortNo
};
lister.Received += (sender, buffer) =>
{
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), DestinationPortNo);
socket.Connect(endPoint);
bool isResult = socket.SendTo(buffer, endPoint) > 0;
socket.Close();
}
string message = string.Join("|", new List <byte>(buffer).Select(x => string.Format("{0}", x.ToString("X2"))));
if (string.IsNullOrEmpty(message) == false)
{
LogManager.GetCurrentClassLogger().Info("[{0}]{1}", Key, message);
}
};
ThreadManager.Instance.Add(Key, lister);
return(0);
}
public MainWindow()
{
InitializeComponent();
var r = new Random();
_port = r.Next(1500, 2000);
_id = Guid.NewGuid();
_sessions = new Dictionary<IPEndPoint, Tuple<Peer, PascalMessageHandler>>();
_listener = new TcpListener(_port);
_comunicationManager = new CommunicationManager(_listener);
_comunicationManager.ConnectionClosed += ChatOnMemberDisconnected;
_comunicationManager.PeerConnected += ChatOnMemberConnected;
_comunicationManager.ConnectionFailed += ChatOnMemberConnectionFailure;
_comunicationManager.PeerDataReceived += OnPeerDataReceived;
_listener.Start();
_discovery = new UdpListener(3000);
_discovery.UdpPacketReceived += DiscoveryOnUdpPacketReceived;
_discovery.Start();
using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
{
socket.EnableBroadcast = true;
var group = new IPEndPoint(IPAddress.Broadcast, 3000);
var hi = Encoding.ASCII.GetBytes("Hi Peer2Net node here:" + _id + ":127.0.0.1:" + _port);
socket.SendTo(hi, group);
socket.Close();
}
}
public void SetUpUdpListenerAndStatsd()
{
udpListener = new UdpListener(serverName, serverPort);
var metricsConfig = new MetricsConfig { StatsdServerName = serverName };
StatsdClient.Metrics.Configure(metricsConfig);
udp = new StatsdUDP(serverName, serverPort);
statsd = new Statsd(udp);
}
/// <summary>Stops the server</summary>
public void Stop()
{
Clients = new Dictionary <int, Client>();
_tcpListener.Stop();
UdpListener.Close();
IsRunning = false;
OnServerStopped?.Invoke(this, new EventArgs());
}
public void SetUpUdpListenerAndStatsd()
{
udpListener = new UdpListener(serverName, serverPort);
var metricsConfig = new MetricsConfig { StatsdServerName = serverName };
StatsdClient.Metrics.Configure(metricsConfig);
udp = new StatsdUDP(serverName, serverPort);
statsd = new Statsd(udp);
}
internal override bool SendUdpBuffer(EndPoint remoteEndPoint, MessageBuffer message, Action <int, SocketError> completed)
{
UdpListener.BeginSendTo(message.Buffer, message.Offset, message.Count, SocketFlags.None, remoteEndPoint, UdpSendCompleted, new UdpSendOperation {
callback = completed, message = message
});
return(true);
}
public void SetUpUdpListener()
{
_udpListener = new UdpListener(hostname: "127.0.0.1", port: 8126);
var metricsConfig = new StatsdConfig {
StatsdServerName = "127.0.0.1", StatsdPort = 8126
};
DogStatsd.Configure(metricsConfig);
}
public CommandIntegrationTests(bool useClientSideAggregation)
{
if (useClientSideAggregation)
{
_optionalClientSideAggregationConfig = new ClientSideAggregationConfig();
}
_udpListener = new UdpListener(serverName, _serverPort);
}
public ClientServer(IPEndPoint ip)
{
m_state = ClientServerState.None;
m_receivedList = new List <Received>();
Listener = new UdpListener(ip);
Handle = new LPTCHandle();
m_model = new ClinetServerModel(this);
m_serverIp = ip;
}
static void Main(string[] args)
{
var udpListener = new UdpListener();
Task.Run(() => udpListener.StartListening());
Task.Run(() => TcpChatListener.Instance.Listen());
Console.WriteLine("Any key to quit...");
Console.ReadKey();
}
public void Close()
{
Listening = false;
if (UdpListener != null)
{
UdpListener.Close();
}
UdpListener = null;
}
public void SetUpUdpListener()
{
udpListener = new UdpListener(serverName, serverPort);
var metricsConfig = new StatsdConfig {
StatsdServerName = serverName, StatsdPort = serverPort
};
StatsdClient.DogStatsd.Configure(metricsConfig);
}
public MySessionListener(UdpTransportFactory transportFactory, UdpListener listener, String uri, Resources resources)
{
this.transportFactory = transportFactory;
this.listener = listener;
this.uri = uri;
this.resources = resources;
listener.SetSession(this);
}
public ListenersBrowserViewModel()
//tag::StartBrowsing[]
{
Title = "Browser";
Items = new ObservableCollection <ReplicatorItem>();
_discovery = new UdpListener(CoreApp.UdpPort);
_discovery.UdpPacketReceived += DiscoveryOnUdpPacketReceived;
_discovery.Start();
}
public void SetUpUdpListener()
{
_udpListener = new UdpListener(serverName, _serverPort);
var metricsConfig = new StatsdConfig {
StatsdServerName = serverName, StatsdPort = _serverPort
};
_dogStatsdService = new DogStatsdService();
_dogStatsdService.Configure(metricsConfig);
}
static void Main(string[] args)
{
PrintInfo();
UdpListener server = new UdpListener(_port);
server.MessageReceived += Server_MessageReceived;
Task.Run(server.Start);
PrintMenu();
}
private void testReceive(string testServerName, int testPort, string testCounterName,
string expectedOutput)
{
UdpListener udpListener = new UdpListener(testServerName, testPort);
Thread listenThread = new Thread(new ParameterizedThreadStart(udpListener.Listen));
listenThread.Start();
DogStatsd.Increment(testCounterName);
while (listenThread.IsAlive) ;
Assert.AreEqual(expectedOutput, udpListener.GetAndClearLastMessages()[0]);
udpListener.Dispose();
}
public static void StartLogging()
{
Contexts.Add(RootContext);
_messageQueue = new MessageQueue();
_udpListener = new UdpListener();
_udpListener.Start(_messageQueue);
_tickTimer = new DispatcherTimer {Interval = UpdatePeriod};
_tickTimer.Tick += tickTimer_Tick;
_tickTimer.Start();
Running = true;
AddLoggerEvent("Log capture started");
}
public void SetUpUdpListener()
{
_udpListener = new UdpListener(_localhostAddress, _randomUnusedLocalPort);
}
public void SetUpUdpListenerAndStatsd()
{
udpListener = new UdpListener(serverName, serverPort);
udp = new StatsdUDP(serverName, serverPort);
}
private void CreateUdpReadThread()
{
//create a new server
var server = new UdpListener();
//start listening for messages and copy the messages back to the client
Task.Factory.StartNew(async () =>
{
while (true)
{
var received = await server.Receive();
propcessText(received);
}
});
}
public void SetUpUdpListener()
{
udpListener = new UdpListener(serverName, serverPort);
var metricsConfig = new StatsdConfig { StatsdServerName = serverName, StatsdPort = serverPort};
StatsdClient.DogStatsd.Configure(metricsConfig);
}