private async void InitConnection() { print("Initializing socket..."); _socket = new DatagramSocket(); _socket.Control.MulticastOnly = true; _socket.MessageReceived += Socket_MessageReceived; print("Listening enabled!"); await _socket.BindServiceNameAsync(_multicastPort); _socket.JoinMulticastGroup(new HostName(_multicastAddress)); outputStream = await _socket.GetOutputStreamAsync(new HostName(_multicastAddress), _multicastPort); writer = new DataWriter(outputStream); print("Socket initialized!"); MulticastAsync("This is a TestMessage"); print("Test message sent!"); }
public static async void switchOn(String severip) { DatagramSocket datagramSocket = null; try { HostName hostName = new HostName(severip); datagramSocket = new DatagramSocket(); IOutputStream outputStream = await datagramSocket.GetOutputStreamAsync(hostName, QUIC_PORT); DataWriter writer = new DataWriter(outputStream); writer.WriteBytes(ON_SWITCH_BYTES); await writer.StoreAsync(); isSwitchOn = true; } catch (Exception exception) { datagramSocket.Dispose(); datagramSocket = null; } }
//Event Fires Off when a message is received on that Socket private async void MessageReceived(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs eventArguments) { //IF Robot is not Running //Msg recived every 10 sec if (!_IsRobotRunning) { try { IOutputStream outputStream = await socket.GetOutputStreamAsync( eventArguments.RemoteAddress, eventArguments.RemotePort); UpdateUi("Found Ev3! Attempting To Connect!"); //Pass the Remote IP address into the brick init method to get a connection BrickInit(eventArguments.RemoteAddress); } catch (Exception) { UpdateUi("Oops Something Went Wrong \nCouldnt Connect to the Ev3 Brick"); } } }
private async Task <bool> OpenAsync() { bool result = false; try { if (writer == null) { var hostname = new HostName(SERVERHOST); socket?.Dispose(); socket = new DatagramSocket(); var port = (ushort)Port.internal_syslog; stream = (await socket.GetOutputStreamAsync(hostname, port.ToString())).AsStreamForWrite(); writer = new StreamWriter(stream); result = true; } } catch (Exception) { Dispose(); } return(result); }
private static async Task BindToSocketAndWriteQuery(DatagramSocket socket, byte[] bytes, CancellationToken cancellationToken) { await socket.BindServiceNameAsync("5353") .AsTask(cancellationToken) .ConfigureAwait(false); socket.JoinMulticastGroup(new HostName("224.0.0.251")); var os = await socket.GetOutputStreamAsync(new HostName("224.0.0.251"), "5353") .AsTask(cancellationToken) .ConfigureAwait(false); using (var writer = new DataWriter(os)) { writer.WriteBytes(bytes); await writer.StoreAsync() .AsTask(cancellationToken) .ConfigureAwait(false); Debug.WriteLine("Sent mDNS query"); writer.DetachStream(); } }
private async void _socketUdp_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { uint stringLength = args.GetDataReader().UnconsumedBufferLength; string receivedMessage = args.GetDataReader().ReadString(stringLength); if (receivedMessage.ToLower().Equals(CommunicationCommands.MCCConnection.ToLower())) { IOutputStream outputStream = await _socketUdp.GetOutputStreamAsync( args.RemoteAddress, args.RemotePort); MCCConnection = new ConnectionInfo(args.RemoteAddress.ToString(), args.RemotePort, outputStream); } MessageReceived?.Invoke(this, new CommunicationMsg(receivedMessage)); } catch (Exception ex) { string error = ex.Message; } }
public async void Broadcast(TorrentManager manager) { if (manager.HasMetadata && manager.Torrent.IsPrivate) { return; } var message = string.Format( "BT-SEARCH * HTTP/1.1\r\nHost: 239.192.152.143:6771\r\nPort: {0}\r\nInfohash: {1}\r\n\r\n\r\n", manager.Engine.Settings.ListenPort, manager.InfoHash.ToHex()); var data = Encoding.ASCII.GetBytes(message); try { var output = await _socket.GetOutputStreamAsync(_hostName, Port); await output.WriteAsync(data.AsBuffer()); } catch { // If data can't be sent, just ignore the error } }
public int SendTo(byte[] data, NetEndPoint remoteEndPoint, ref int errorCode) { try { DataWriter writer; if (!_peers.TryGetValue(remoteEndPoint, out writer)) { var outputStream = _datagramSocket.GetOutputStreamAsync(remoteEndPoint.HostName, remoteEndPoint.PortStr) .AsTask() .Result; writer = new DataWriter(outputStream); _peers.Add(remoteEndPoint, writer); } writer.WriteBytes(data); var res = writer.StoreAsync().AsTask().Result; return((int)res); } catch (Exception) { return(-1); } }
private async void SendMessage(SensorReading newSensorReading) { try { _timer.Stop(); var socket = new DatagramSocket(); var message = BuildMessage(newSensorReading); using (var stream = await socket.GetOutputStreamAsync(new HostName(_ipAddress), _port)) { await stream.WriteAsync(message.AsBuffer()); await stream.FlushAsync(); } _timer.Start(); } catch (Exception ex) { ExceptionEvent(ex); } }
public static void AcceptClient(DatagramSocket listener, DatagramSocketMessageReceivedEventArgs args) { new Task(async() => { // Retrieve client IP info byte[] serverIPBytes = CryptographicBuffer.ConvertStringToBinary(serverIP, BinaryStringEncoding.Utf8).ToArray(); //HostName clientIP = args.RemoteAddress; //string clientPort = args.RemotePort; DataReader reader = args.GetDataReader(); uint numBytesLoaded = await reader.LoadAsync(1024); //byte[] buffer = new byte[reader.UnconsumedBufferLength]; //reader.ReadBytes(buffer); string clientIP = CryptographicBuffer.ConvertBinaryToString(BinaryStringEncoding.Utf8, reader.ReadBuffer(reader.UnconsumedBufferLength)); DataWriter writer = new DataWriter(await listener.GetOutputStreamAsync(new HostName(clientIP), Config.Ports.FindServer.ToString())); writer.WriteBytes(serverIPBytes); await writer.StoreAsync(); // necessary?? // Reset listening status await listener.ConnectAsync(new HostName("0.0.0.0"), Config.Ports.FindServer.ToString()); }).Start(); }
private async void initSockets(string host, int inputPort, int outputPort) { // input socket inputSocket = new DatagramSocket(); Windows.Networking.HostName serverAddr = new Windows.Networking.HostName(host); Stream streamOut = (await inputSocket.GetOutputStreamAsync(serverAddr, "" + inputPort)).AsStreamForWrite(); inputWriter = new StreamWriter(streamOut); // output socket outputSocket = new DatagramSocket(); outputSocket.MessageReceived += Socket_MessageReceived; try { await outputSocket.BindServiceNameAsync("" + outputPort); } catch (Exception e) { Debug.Log(e.ToString()); Debug.Log(Windows.Networking.Sockets.SocketError.GetStatus(e.HResult).ToString()); return; } }
public async Task <bool> Send(string buffer) { try { System.Diagnostics.Debug.WriteLine("Message Sent: " + buffer); if (msocketSend == null) { await InitializeSend(); } HostName mcast = new HostName(mAddress); DataWriter writer = new DataWriter(await msocketSend.GetOutputStreamAsync(mcast, mPort)); if (writer != null) { writer.WriteString(buffer); uint result = await writer.StoreAsync(); bool bresult = await writer.FlushAsync(); writer.DetachStream(); writer.Dispose(); return(true); } } catch (Exception exception) { // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { return(false); } return(false); } return(false); }
/// <summary> /// Attempts to send a magic packet to the desination hostname, on the specified port with the specified MAC address. /// </summary> /// <param name="destination">Destination hostname or IP address.</param> /// <param name="destinationPort">Destination port number.</param> /// <param name="targetMac">Destination MAC address. Bytes can be separated by colons, dashes, or nothing.</param> /// <returns>True if magic packet is sent successfully, false otherwise.</returns> public async Task <bool> SendMagicPacket(Windows.Networking.HostName destination, uint destinationPort, string targetMac) { try { DatagramSocket _socket = new DatagramSocket(); using (var stream = await _socket.GetOutputStreamAsync(destination, destinationPort.ToString())) { //Split on common MAC separators char?splitChar = null; if (targetMac.Contains('-')) { splitChar = '-'; } else if (targetMac.Contains(':')) { splitChar = ':'; } else if (targetMac.Contains(' ')) { splitChar = ' '; } //Turn MAC into array of bytes byte[] macAsArray; if (splitChar != null) { macAsArray = targetMac.Split((char)splitChar) .Select(b => Convert.ToByte(b, 16)) .ToArray <byte>(); } else { //Jump through MAC-string, reading 2 chars at a time macAsArray = Enumerable.Range(0, targetMac.Length) .Where(x => x % 2 == 0) .Select(x => Convert.ToByte(targetMac.Substring(x, 2), 16)) //16 = hexadecimal .ToArray(); } List <byte> magicPacket = new List <byte> { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; //A WoLAN magic packet is just FF FF FF FF FF FF, then the target MAC adress repeated 16 times. for (int i = 0; i < 16; i++) { magicPacket = magicPacket.Concat(macAsArray).ToList(); } using (DataWriter writer = new DataWriter(stream)) { writer.WriteBytes(magicPacket.ToArray <byte>()); await writer.StoreAsync(); await writer.FlushAsync(); return(true); } } } catch (Exception e) { Debug.WriteLine(e); return(false); } }
/// <summary> /// Send a packet to the specified ipEndPoint. This feature is unique to UDP because of its connectionless structure. /// </summary> /// <param name="packet">Packet to send</param> /// <param name="ipEndPoint">The target ipEndPoint</param> private void SendPacketSpecific <packetObjectType>(IPacket packet, IPEndPoint ipEndPoint) { #if FREETRIAL if (ipEndPoint.Address == IPAddress.Broadcast) { throw new NotSupportedException("Unable to send UDP broadcast datagram using this version of NetworkComms.Net. Please purchase a commercial license from www.networkcomms.net which supports UDP broadcast datagrams."); } #endif byte[] headerBytes = new byte[0]; if (ConnectionInfo.ApplicationLayerProtocol == ApplicationLayerProtocolStatus.Enabled) { long packetSequenceNumber; lock (sendLocker) { //Set packet sequence number inside sendLocker //Increment the global counter as well to ensure future connections with the same host can not create duplicates Interlocked.Increment(ref NetworkComms.totalPacketSendCount); packetSequenceNumber = packetSequenceCounter++; packet.PacketHeader.SetOption(PacketHeaderLongItems.PacketSequenceNumber, packetSequenceNumber); } headerBytes = packet.SerialiseHeader(NetworkComms.InternalFixedSendReceiveOptions); } else { if (packet.PacketHeader.PacketType != Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Unmanaged)) { throw new UnexpectedPacketTypeException("Only 'Unmanaged' packet types can be used if the NetworkComms.Net application layer protocol is disabled."); } if (packet.PacketData.Length == 0) { throw new NotSupportedException("Sending a zero length array if the NetworkComms.Net application layer protocol is disabled is not supported."); } } //We are limited in size for the isolated send if (headerBytes.Length + packet.PacketData.Length > maximumSingleDatagramSizeBytes) { throw new CommunicationException("Attempted to send a UDP packet whose serialised size was " + (headerBytes.Length + packet.PacketData.Length).ToString() + " bytes. The maximum size for a single UDP send is " + maximumSingleDatagramSizeBytes.ToString() + ". Consider using a TCP connection to send this object."); } if (NetworkComms.LoggingEnabled) { NetworkComms.Logger.Debug("Sending a UDP packet of type '" + packet.PacketHeader.PacketType + "' from " + ConnectionInfo.LocalIPEndPoint.Address + ":" + ConnectionInfo.LocalIPEndPoint.Port.ToString() + " to " + ipEndPoint.Address + ":" + ipEndPoint.Port.ToString() + " containing " + headerBytes.Length.ToString() + " header bytes and " + packet.PacketData.Length.ToString() + " payload bytes."); } //Prepare the single byte array to send byte[] udpDatagram; if (ConnectionInfo.ApplicationLayerProtocol == ApplicationLayerProtocolStatus.Enabled) { udpDatagram = packet.PacketData.ThreadSafeStream.ToArray(headerBytes.Length); //Copy the header bytes into the datagram Buffer.BlockCopy(headerBytes, 0, udpDatagram, 0, headerBytes.Length); } else { udpDatagram = packet.PacketData.ThreadSafeStream.ToArray(); } #if WINDOWS_PHONE || NETFX_CORE var getStreamTask = socket.GetOutputStreamAsync(new HostName(ipEndPoint.Address.ToString()), ipEndPoint.Port.ToString()).AsTask(); getStreamTask.Wait(); var outputStream = getStreamTask.Result; outputStream.WriteAsync(WindowsRuntimeBufferExtensions.AsBuffer(udpDatagram)).AsTask().Wait(); outputStream.FlushAsync().AsTask().Wait(); #else udpClient.Send(udpDatagram, udpDatagram.Length, ipEndPoint); #endif if (NetworkComms.LoggingEnabled) { NetworkComms.Logger.Trace("Completed send of a UDP packet of type '" + packet.PacketHeader.PacketType + "' from " + ConnectionInfo.LocalIPEndPoint.Address + ":" + ConnectionInfo.LocalIPEndPoint.Port.ToString() + " to " + ipEndPoint.Address + ":" + ipEndPoint.Port.ToString() + "."); } }
static async Task BindToSocketAndWriteQuery(DatagramSocket socket, byte[] bytes, CancellationToken cancellationToken) { #if !WINDOWS_PHONE try { // Try to bind using port 5353 first var adapter = NetworkInformation.GetInternetConnectionProfile()?.NetworkAdapter; if (adapter != null) { await socket.BindServiceNameAsync("5353", adapter) .AsTask(cancellationToken) .ConfigureAwait(false); } else { await socket.BindServiceNameAsync("5353") .AsTask(cancellationToken) .ConfigureAwait(false); } } catch (Exception) { // If it fails, use the default var adapter = NetworkInformation.GetInternetConnectionProfile()?.NetworkAdapter; if (adapter != null) { await socket.BindServiceNameAsync("", adapter) .AsTask(cancellationToken) .ConfigureAwait(false); } else { await socket.BindServiceNameAsync("") .AsTask(cancellationToken) .ConfigureAwait(false); } } #else try { await socket.BindServiceNameAsync("5353") .AsTask(cancellationToken) .ConfigureAwait(false); } catch (Exception) { // fallback to "" for WinPhone 10 await socket.BindServiceNameAsync("") .AsTask(cancellationToken) .ConfigureAwait(false); } #endif socket.JoinMulticastGroup(new HostName("224.0.0.251")); var os = await socket.GetOutputStreamAsync(new HostName("224.0.0.251"), "5353") .AsTask(cancellationToken) .ConfigureAwait(false); using (var writer = new DataWriter(os)) { writer.WriteBytes(bytes); await writer.StoreAsync() .AsTask(cancellationToken) .ConfigureAwait(false); Debug.WriteLine("Sent mDNS query"); writer.DetachStream(); } }
public async Task <CharGenResult> WriteUdpAsync(HostName address, string service, string data) { try { var haveUdpSocket = EnsureUdpSocket(); if (haveUdpSocket != null) { // Was unable to create the socket. return(haveUdpSocket); } var stream = await udpSocket.GetOutputStreamAsync(address, service); if (string.IsNullOrEmpty(data)) { // A blank string, when written to a data writer, won't actually result in a // UDP packet being sent. For the special case of not sending any data, // use the WriteAsync on the socket's OutputStream directly. var b = new Windows.Storage.Streams.Buffer(0); await stream.WriteAsync(b); Stats.NWrites++; } else { var dw = new DataWriter(stream); dw.WriteString(data); await dw.StoreAsync(); Stats.NWrites++; } Log(ClientOptions.Verbosity.Verbose, $"Client: UDP: Sent request on local port {udpSocket.Information.LocalPort} request {data}"); // // Wait for an answer // const int START_DELAY_MS = 10; int currTotalDelay = 0; int currDelay = START_DELAY_MS; CharGenResult udpResult = null; while (!UdpResults.TryRemove(udpSocket.Information.LocalPort, out udpResult)) { await Task.Delay(currDelay); currTotalDelay += currDelay; currDelay = Math.Min(currDelay * 2, Options.MaxPollLoopInMilliseconds); // Do an exponential backup up to max (10 seconds) if (currTotalDelay >= Options.MaxWaitInMilliseconds) { Log($"ERROR: Client: reply from {address} took too long (outgoing data={data})"); var delta = DateTime.UtcNow.Subtract(SocketStartTime).TotalSeconds; udpResult = CharGenResult.MakeFailed(SocketErrorStatus.ConnectionTimedOut, delta); break; } } return(udpResult); } catch (Exception ex) { Stats.NExceptions++; Log($"ERROR: Client: Writing {data} to {address} exception {ex.Message}"); var delta = DateTime.UtcNow.Subtract(SocketStartTime).TotalSeconds; return(CharGenResult.MakeFailed(ex, delta)); } }
/// <summary> /// 搜索设备私有函数 /// </summary> /// <param name="timeout">超时时间 毫秒</param> /// <returns>Yeelight对象</returns> private async static Task <IList <Yeelight> > SearchDeviceHelper(int timeout) { // 创建Socket DatagramSocket udp = new DatagramSocket(); // 绑定随机端口 await udp.BindServiceNameAsync(""); // 获取输出流 var outputStream = await udp.GetOutputStreamAsync(MULTICAST_HOST, MULTICAST_PORT); // Yeelight列表 Dictionary <string, Yeelight> yeelightList = new Dictionary <string, Yeelight>(); // 处理回应 udp.MessageReceived += (sender, args) => { // 读取对象 var reader = args.GetDataReader(); // 读取设备信息 string rawDevInfo = reader.ReadString(reader.UnconsumedBufferLength); try { // 构造Yeelight对象 Yeelight device = new Yeelight(rawDevInfo); // 是否已存在 if (yeelightList.ContainsKey(device.Id)) { // 替换 yeelightList[device.Id] = device; } else { // 新增 yeelightList.Add(device.Id, device); } } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } }; // 创建数据写入对象 using (DataWriter writer = new DataWriter(outputStream)) { // 写入缓冲区 writer.WriteString(SEARCH_DEVICE_MULTCAST_CONTENT); // 发送数据 await writer.StoreAsync(); // 分离流 writer.DetachStream(); // 等待 await Task.Delay(timeout); } // 清理资源 udp.Dispose(); return(yeelightList.Values.ToList <Yeelight>()); }
private async Task <T> BroadcastMessagePayloadAsync <T>(Windows.Networking.HostName hostName, FrameHeader header, MessageType type, byte[] payload) where T : LifxResponse { #if DEBUG MemoryStream ms = new MemoryStream(); await WritePacketToStreamAsync(ms.AsOutputStream(), header, (UInt16)type, payload).ConfigureAwait(false); var data = ms.ToArray(); System.Diagnostics.Debug.WriteLine( string.Join(",", (from a in data select a.ToString("X2")).ToArray())); #endif if (hostName == null) { hostName = new Windows.Networking.HostName("255.255.255.255"); } TaskCompletionSource <T> tcs = null; if (//header.AcknowledgeRequired && header.Identifier > 0 && typeof(T) != typeof(UnknownResponse)) { tcs = new TaskCompletionSource <T>(); Action <LifxResponse> action = (r) => { if (!tcs.Task.IsCompleted) { if (r.GetType() == typeof(T)) { tcs.SetResult((T)r); } else { } } }; taskCompletions[header.Identifier] = action; } using (var stream = await _socket.GetOutputStreamAsync(hostName, Port)) { await WritePacketToStreamAsync(stream, header, (UInt16)type, payload).ConfigureAwait(false); } T result = default(T); if (tcs != null) { var _ = Task.Delay(1000).ContinueWith((t) => { if (!t.IsCompleted) { tcs.TrySetException(new TimeoutException()); } }); try { result = await tcs.Task.ConfigureAwait(false); } finally { taskCompletions.Remove(header.Identifier); } } return(result); }
private async Task ExecuteDiscoveryTask() { int repeatTime = EndpointController.REPEAT_DISCOVERY_TASK / 2; while (running) { Debug.WriteLine("#> [DiscoveryCloudletMulticast]: Started Cloudlet Discovery using Multicast UDP"); retry = 0; DatagramSocket socketSent = null; DatagramSocket socketReplay = null; try { socketSent = new DatagramSocket(); await socketSent.BindEndpointAsync(null, string.Empty); socketSent.JoinMulticastGroup(ip); socketReplay = new DatagramSocket(); socketReplay.MessageReceived += SocketOnMessageReceived; await socketReplay.BindServiceNameAsync(replyCloudletPort.ToString()); using (DataWriter writer = new DataWriter(await socketSent.GetOutputStreamAsync(ip, multicastPort.ToString()))) { while (retry < 60 && running) { writer.WriteString("mpos_cloudlet_req"); await writer.StoreAsync(); await writer.FlushAsync(); await Task.Delay(500); retry++; } } } catch (IOException e) { Debug.WriteLine("## [DiscoveryCloudletMulticast]: Any problem with i/o in multicast system!\n" + e.ToString()); } finally { socketSent.Dispose(); socketReplay.Dispose(); socketSent = null; socketReplay = null; } if (running) { Debug.WriteLine(">> [DiscoveryCloudletMulticast]: Retry Discovery Cloudlet, in " + repeatTime + " ms"); await Task.Delay(repeatTime); } else { Debug.WriteLine("#> [DiscoveryCloudletMulticast]: Finished Discovery Cloudlet"); } } }
//This code will work on win phone too public override async Task <HashSet <Tuple <Uri, Uri> > > GetDeviceLocations(string schema, Func <string, string, byte[]> createSsdpRequest, Func <byte[], int, Uri> parseSsdpResponse) { var remoteIp = new HostName("239.255.255.250"); var remotePort = "1900"; // standard multicast address+port for SSDP var reqbuf = WindowsRuntimeBufferExtensions.AsBuffer( createSsdpRequest(remoteIp.RawName + ":" + remotePort, schema)); var locations = new HashSet <Tuple <Uri, Uri> >(); using (var socket = new DatagramSocket()) { socket.MessageReceived += (sender, e) => { if (e.LocalAddress.IPInformation != null && e.LocalAddress.IPInformation.NetworkAdapter.IanaInterfaceType == 24) { return; // loopback } // any loopback renderer will also report itself on the actual network, and I don't want to show duplicates using (var reader = e.GetDataReader()) { var responsebuf = new Byte[reader.UnconsumedBufferLength - 1]; reader.ReadBytes(responsebuf); if (_progress != null) { _progress.Report("Received from " + e.RemoteAddress.DisplayName + ":" + e.RemotePort + vbCrLf + Encoding.UTF8.GetString(responsebuf, 0, responsebuf.Length)); } var location = parseSsdpResponse(responsebuf, responsebuf.Length); if (location != null) { locations.Add(Tuple.Create(location, new Uri("http://" + e.LocalAddress.CanonicalName))); } } }; // CAPABILITY: PrivateNetworks #if WINDOWS_PHONE_APP ConnectionProfile connectionProfile = NetworkInformation.GetInternetConnectionProfile(); await socket.BindEndpointAsync(null, ""); #else ConnectionProfile connectionProfile = NetworkInformation.GetInternetConnectionProfile(); await socket.BindServiceNameAsync("", connectionProfile.NetworkAdapter); #endif socket.Control.OutboundUnicastHopLimit = 1; socket.JoinMulticastGroup(remoteIp); // Alas there's no WinRT equivalent of ReuseAddress using (var stream = await socket.GetOutputStreamAsync(new HostName("239.255.255.250"), remotePort)) { await stream.WriteAsync(reqbuf); await Task.Delay(20); await stream.WriteAsync(reqbuf); await Task.Delay(20); await stream.WriteAsync(reqbuf); } await Task.Delay(1200); } return(locations); }
protected async Task <long[]> PingService(bool isTcp, int pingRounds) { long[] pings = new long[pingRounds]; watch.Reset(); if (isTcp) { streamSocket = new StreamSocket(); await streamSocket.ConnectAsync(hostName, server.PingTcpPort.ToString()); DataWriter writer = new DataWriter(streamSocket.OutputStream); DataReader reader = new DataReader(streamSocket.InputStream); int count = 0; for (int i = 0; i < pingRounds; i++) { watch.Start(); writer.WriteString("pigado" + i); await writer.StoreAsync(); await writer.FlushAsync(); reader.InputStreamOptions = InputStreamOptions.Partial; await reader.LoadAsync(256); watch.Stop(); pings[count++] = watch.ElapsedMilliseconds; watch.Reset(); if (halted) { throw new InterruptedException("PingService TCP was aborted externally!"); } await Task.Delay(500); } Array.Sort <long>(pings); Close(ref writer); Close(ref reader); Close(ref streamSocket); } else { datagramSocket = new DatagramSocket(); int count = 0; datagramSocket.MessageReceived += delegate(DatagramSocket socket, DatagramSocketMessageReceivedEventArgs args) { watch.Stop(); pings[count++] = watch.ElapsedMilliseconds; watch.Reset(); }; //for receive packets string port = server.PingUdpPort.ToString(); await datagramSocket.BindServiceNameAsync(port); using (DataWriter writer = new DataWriter(await datagramSocket.GetOutputStreamAsync(hostName, port))) { for (int i = 0; i < pingRounds; i++) { watch.Start(); writer.WriteString("pigado" + i); await writer.StoreAsync(); await writer.FlushAsync(); if (halted) { throw new InterruptedException("PingService UDP was aborted externally!"); } await Task.Delay(500); } } Array.Sort <long>(pings); Close(ref datagramSocket); } return(pings); }
async Task <bool> Send(string ip, string Message) { try { if (msocketSend == null) { return(false); } // Add Device Information string command = CompanionProtocol.GetCommandFromMessage(Message); Dictionary <string, string> parameters = CompanionProtocol.GetParametersFromMessage(Message); if (!string.IsNullOrEmpty(command)) { if (parameters == null) { parameters = new Dictionary <string, string>(); } if ((parameters != null) && (!parameters.ContainsKey(CompanionProtocol.parameterIPAddress)) && (!parameters.ContainsKey(CompanionProtocol.parameterName)) && (!parameters.ContainsKey(CompanionProtocol.parameterKind)) && (!parameters.ContainsKey(CompanionProtocol.parameterID))) { parameters.Add(CompanionProtocol.parameterID, LocalCompanionDevice.Id); parameters.Add(CompanionProtocol.parameterIPAddress, LocalCompanionDevice.IPAddress); parameters.Add(CompanionProtocol.parameterKind, LocalCompanionDevice.Kind); parameters.Add(CompanionProtocol.parameterName, LocalCompanionDevice.Name); Message = CompanionProtocol.CreateCommand(command, parameters); } } HostName mcast; string port; if ((string.IsNullOrEmpty(ip)) || (string.Equals(ip, MulticastIPAddress))) { port = MulticastUDPPort.ToString(); mcast = new HostName(MulticastIPAddress); } else { port = UnicastUDPPort.ToString(); mcast = new HostName(ip); } DataWriter writer = new DataWriter(await msocketSend.GetOutputStreamAsync(mcast, port)); if (writer != null) { writer.WriteString(Message); uint result = await writer.StoreAsync(); bool bresult = await writer.FlushAsync(); writer.DetachStream(); writer.Dispose(); System.Diagnostics.Debug.WriteLine("Message Sent to: " + mcast.CanonicalName + ":" + port + " content: " + Message); return(true); } } catch (Exception exception) { // If this is an unknown status it means that the error is fatal and retry will likely fail. if (SocketError.GetStatus(exception.HResult) == SocketErrorStatus.Unknown) { return(false); } return(false); } return(false); }
public static async Task <List <string> > GetAvaliable(string port) { var list = new List <string>(); #if UNITY_EDITOR using (var socket = new UdpClient { Ttl = 1 }) { var timer = new System.Timers.Timer { AutoReset = false, Interval = 500 }; var str = Encoding.Default.GetBytes("IP?"); var ct = new CancellationTokenSource(); var eventhandler = new EventWaitHandle(false, EventResetMode.ManualReset); timer.Elapsed += (sender, args) => { ct.Cancel(); }; ct.Token.Register(async() => { while (socket.Available > 0) { var rec = await socket.ReceiveAsync(); list.Add(rec.RemoteEndPoint.Address.ToString()); } eventhandler.Set(); }); await socket.SendAsync(str, str.Length, UniversalTcpServer.Multicast, int.Parse(port)); timer.Start(); var t = Task.Run(async() => { while (true) { var rec = await socket.ReceiveAsync(); list.Add(rec.RemoteEndPoint.Address.ToString()); } }, ct.Token); eventhandler.WaitOne(); } #elif UNITY_WSA using (var socket = new DatagramSocket()) { var stream = await socket.GetOutputStreamAsync(new HostName(UniversalTcpServer.Multicast), port); Logs.Log($"Getting stream form {UniversalTcpServer.Multicast}:{port}"); socket.MessageReceived += async(sender, args) => { var reader = new StreamReader(args.GetDataStream().AsStreamForRead()); var str = await reader.ReadToEndAsync(); Logs.Log($"{str} from {args.RemoteAddress.RawName}"); list.Add(args.RemoteAddress.RawName); }; using (var data = new DataWriter(stream)) { data.WriteString("IP?"); var i = await data.StoreAsync(); var b = await data.FlushAsync(); } Logs.Log($"Client udp socket: {socket.Information.LocalAddress}:{socket.Information.LocalPort}"); await Task.Delay(1000); } #endif return(list); }
public async ValueTask Init(ChannelReader <byte[]> outboundChan, ILocalAdapter localAdapter, CancellationToken cancellationToken = default) { var destination = localAdapter.Destination; IAsyncAction connectTask; var dev = NetworkInformation.GetInternetConnectionProfile().NetworkAdapter; switch (destination.TransportProtocol) { case TransportProtocol.Tcp: client = new StreamSocket(); client.Control.NoDelay = true; connectTask = client.ConnectAsync(new HostName(server), serviceName, SocketProtectionLevel.PlainSocket, dev); tcpInputStream = client.InputStream; break; case TransportProtocol.Udp: cryptor = null; // Shadowsocks does not require a handshake for UDP transport udpClient = new DatagramSocket(); // MessageReceived must be subscribed at this point udpClient.MessageReceived += UdpClient_MessageReceived; await udpClient.BindServiceNameAsync(string.Empty, dev).AsTask(cancellationToken).ConfigureAwait(false); udpOutputStream = await udpClient.GetOutputStreamAsync(new HostName(server), serviceName).AsTask(cancellationToken).ConfigureAwait(false); return; default: throw new NotImplementedException("Unknown transport protocol"); } byte[] firstBuf = Array.Empty <byte>(); var firstBufCancel = new CancellationTokenSource(500); try { if (await outboundChan.WaitToReadAsync(firstBufCancel.Token).ConfigureAwait(false)) { outboundChan.TryRead(out firstBuf); } } catch (OperationCanceledException) { } finally { firstBufCancel.Dispose(); } int firstBufLen = firstBuf.Length; int requestPayloadLen = firstBufLen + destination.Host.Size + 4; // Later will be reused to store dec iv var requestPayload = sendArrayPool.Rent(Math.Max(requestPayloadLen, (int)cryptor.IvLen)); var headerLen = destination.FillSocks5StyleAddress(requestPayload); firstBuf.CopyTo(requestPayload.AsSpan(headerLen)); var encryptedFirstSeg = sendArrayPool.Rent(requestPayloadLen + 66); // Reserve space for IV or salt + 2 * tag + size var ivLen = Encrypt(Array.Empty <byte>(), encryptedFirstSeg); // Fill IV/salt first var encryptedFirstSegLen = ivLen + Encrypt(requestPayload.AsSpan(0, headerLen + firstBufLen), encryptedFirstSeg.AsSpan((int)ivLen)); try { await connectTask.AsTask(cancellationToken).ConfigureAwait(false); } catch (Exception) { sendArrayPool.Return(requestPayload); sendArrayPool.Return(encryptedFirstSeg, true); throw; } try { // Recv iv first, then GetRecvBufSizeHint will not bother with iv stuff receiveIvTask = ReceiveIv(requestPayload, cancellationToken); _ = client.OutputStream.WriteAsync(encryptedFirstSeg.AsBuffer(0, (int)encryptedFirstSegLen)).AsTask(cancellationToken); } finally { sendArrayPool.Return(encryptedFirstSeg, true); } }
public async Task DiscoverBridge(TimeSpan timeOut) { var multicastIP = new HostName("239.255.255.250"); var foundBridge = false; using (var socket = new DatagramSocket()) { socket.MessageReceived += async(sender, args) => { var reader = args.GetDataReader(); var bytesRemaining = reader.UnconsumedBufferLength; foreach (var line in reader.ReadString(bytesRemaining).Split(new String[1] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries)) { if (line.StartsWith("LOCATION")) { var address = line.Split(new char[1] { ':' }, 2)[1]; var message = await _client.GetAsync(address); if (message.IsSuccessStatusCode) { var messageContent = await message.Content.ReadAsStringAsync(); var buffer = Encoding.UTF8.GetBytes(messageContent); } } } foundBridge = true; }; await socket.BindEndpointAsync(null, string.Empty); socket.JoinMulticastGroup(multicastIP); while (true) { foundBridge = false; using (var stream = await socket.GetOutputStreamAsync(multicastIP, "1900")) using (var writer = new DataWriter(stream)) { var request = new StringBuilder(); request.AppendLine("M-SEARCH * HTTP/1.1"); request.AppendLine("HOST: 239.255.255.250:1900"); request.AppendLine("MAN: ssdp:discover"); request.AppendLine("MX: 3"); request.AppendLine("ST: ssdp:all"); writer.WriteString(request.ToString()); await writer.StoreAsync(); if (timeOut > TimeSpan.Zero) { await Task.Delay(timeOut); } if (foundBridge) { break; } } } } }
async void MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { using (DataReader dataReader = args.GetDataReader()) { dataReader.ByteOrder = ByteOrder.LittleEndian; Debug.WriteLine("buffer lntgh: " + dataReader.UnconsumedBufferLength); while (dataReader.UnconsumedBufferLength != 0) { Code code = (Code)dataReader.ReadInt32(); Packet p; switch (code) { case Code.Connecting: { Connected = true; hostName = args.RemoteAddress; Debug.WriteLine("Connected to: " + hostName); try { Stream output = (await socket.GetOutputStreamAsync(hostName, Port)).AsStreamForWrite(); writer = new BinaryWriter(output); } catch (Exception e) { Debug.WriteLine(e.Message); } send_buffer.Add(new Connected()); p = null; break; } case Code.Ping: { p = Ping.ConstructPacket(dataReader); break; } case Code.Pong: { p = Pong.ConstructPacket(dataReader); break; } case Code.Acknowledge: { p = Acknowledge.ConstructPacket(dataReader); break; } case Code.OtherPlayerCreationData: { p = AddOtherPlayer.ConstructPacket(dataReader); send_buffer.Add(new Acknowledge(p.Code)); break; } case Code.Input: { p = Input.ConstructPacket(dataReader); break; } case Code.EntityXYCorrection: { p = EntityCorrection.ConstructPacket(dataReader); break; } default: p = null; break; } if (p != null) { receive_buffer.Add(p); } else { Debug.WriteLine("Unrecognized packet " + code); break; } } } }
private async void server_MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { // Get InputStream BinaryReader reader; try { reader = new BinaryReader(args.GetDataStream().AsStreamForRead()); } catch (Exception e) { if (SocketError.GetStatus(e.HResult) != SocketErrorStatus.ConnectionResetByPeer) { throw; } return; } byte[] header = reader.ReadBytes(8); string headerstr = Encoding.UTF8.GetString(header, 0, header.Length); Guid guid = new Guid(reader.ReadBytes(16)); ServerMessageHandler handler = ServerMessageHandler.Close; // Identify the handler if (clientList.ContainsKey(guid) && clientList[guid].Closing) { handler = ServerMessageHandler.Close; } else if (!clientList.ContainsKey(guid) && headerstr != "SHClCONN" && headerstr != "SHClPING") { handler = ServerMessageHandler.Close; } else { if (headerstr == "SHClPING") { handler = ServerMessageHandler.Ping; } if (headerstr == "SHClCONN") { handler = ServerMessageHandler.Connect; } if (headerstr == "SHClCLSE") { handler = ServerMessageHandler.Close; } if (headerstr == "SHClDATA") { handler = ServerMessageHandler.Data; } if (headerstr == "SHClSLNT") { handler = ServerMessageHandler.Silent; } } BinaryWriter writer = null; // For data, we don't need to get the output stream if (handler != ServerMessageHandler.Data && handler != ServerMessageHandler.Silent) { var outputStream = await sender.GetOutputStreamAsync(args.RemoteAddress, args.RemotePort); writer = new BinaryWriter(outputStream.AsStreamForWrite()); } // Handle the message switch (handler) { case ServerMessageHandler.Close: Header_CLSE(guid, writer); break; case ServerMessageHandler.Connect: Header_CONN(guid, reader, writer); break; case ServerMessageHandler.Ping: Header_PING(guid, writer); break; case ServerMessageHandler.Data: Header_DATA(guid, reader); break; case ServerMessageHandler.Silent: Header_SLNT(guid); break; } }
/// <summary> /// Sends DHCP reply /// </summary> /// <param name="msgType">Type of DHCP message to send</param> /// <param name="ip">IP for client</param> /// <param name="replyData">Reply options (will be sent if requested)</param> /// <param name="otherForceOptions">Force reply options (will be sent anyway)</param> private async void SendDHCPReply(DHCPMsgType msgType, IPAddress ip, DHCPReplyOptions replyData, Dictionary <DHCPOption, byte[]> otherForceOptions, IEnumerable <DHCPOption> forceOptions) { var replyBuffer = requestData; replyBuffer.op = 2; // Reply replyBuffer.yiaddr = ip.GetAddressBytes(); // Client's IP if (replyData.ServerIpAddress != null) { replyBuffer.siaddr = replyData.ServerIpAddress.GetAddressBytes(); } replyBuffer.options = CreateOptionStruct(msgType, replyData, otherForceOptions, forceOptions); // Options if (!string.IsNullOrEmpty(dhcpServer.ServerName)) { var serverNameBytes = Encoding.ASCII.GetBytes(dhcpServer.ServerName); int len = (serverNameBytes.Length > 63) ? 63 : serverNameBytes.Length; Array.Copy(serverNameBytes, replyBuffer.sname, len); replyBuffer.sname[len] = 0; } //lock (requestSocket) { var DataToSend = BuildDataStructure(replyBuffer); if (DataToSend.Length < 300) { var sendArray = new byte[300]; Array.Copy(DataToSend, 0, sendArray, 0, DataToSend.Length); DataToSend = sendArray; } if ((replyBuffer.giaddr[0] == 0) && (replyBuffer.giaddr[1] == 0) && (replyBuffer.giaddr[2] == 0) && (replyBuffer.giaddr[3] == 0)) { //requestSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true); //endPoint = new IPEndPoint(dhcpServer.BroadcastAddress, PORT_TO_SEND_TO_CLIENT); //var udp = new UdpClient(); //udp.EnableBroadcast = true; //udp.Send(DataToSend, DataToSend.Length, new IPEndPoint(dhcpServer.BroadcastAddress, 68)); //udp.Close(); var datagramsocket = new Windows.Networking.Sockets.DatagramSocket(); using (var stream = await datagramsocket.GetOutputStreamAsync(new Windows.Networking.HostName(dhcpServer.BroadcastAddress), PORT_TO_SEND_TO_CLIENT.ToString())) { using (var datawriter = new Windows.Storage.Streams.DataWriter(stream)) { datawriter.WriteBytes(DataToSend); await datawriter.StoreAsync(); } } } else { //requestSocket .SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, false); //endPoint = new IPEndPoint(new IPAddress(replyBuffer.giaddr), PORT_TO_SEND_TO_RELAY); //requestSocket.SendTo(DataToSend, endPoint); using (var stream = await requestSocket.GetOutputStreamAsync(new Windows.Networking.HostName(new IPAddress(replyBuffer.giaddr).ToString()), PORT_TO_SEND_TO_RELAY.ToString())) { using (var datawriter = new Windows.Storage.Streams.DataWriter(stream)) { datawriter.WriteBytes(DataToSend); await datawriter.StoreAsync(); } } } } }
private static async void MessageReceived(DatagramSocket sender, DatagramSocketMessageReceivedEventArgs args) { try { if (App.isRPi && peer == null) { IOutputStream outputStream = await sender.GetOutputStreamAsync(args.RemoteAddress, args.RemotePort); // It might happen that the OnMessage was invoked more than once before the GetOutputStreamAsync call // completed. In this case we will end up with multiple streams - just keep one of them. object syncRoot = new object(); lock (syncRoot) { peer = new RemotePeer(outputStream, args.RemoteAddress, args.RemotePort); } socketIsConnected = true; } var readPacket = args.GetDataReader(); if (readPacket == null) { Debug.WriteLine("DataReader is null"); return; } uint buffLen = readPacket.UnconsumedBufferLength; if (buffLen == 0) { Debug.WriteLine("Buffer is empty"); return; } List <byte> bytes = new List <byte>(); while (buffLen > 0) { byte b = readPacket.ReadByte(); bytes.Add(b); buffLen--; } lastCmdReceived = MainPage.stopwatch.ElapsedMilliseconds; if (App.isRPi) { if (bytes[0] == '#') { MultiWii.evaluateCustomCommand(bytes); } else { MultiWii.sendRequestMSP(bytes); } } else { if (bytes[0] == '#') { MultiWii.evaluateCustomCommand(bytes); } else { MultiWii.evaluateResponseMSP(bytes); } await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () => { var currentPage = ((ContentControl)Window.Current.Content).Content as Page; var droneStatus = currentPage.FindName("droneStatus") as Image; droneStatus.Opacity = 1; }); } } catch (Exception ex) { Debug.WriteLine("OnConnection() - " + ex.Message); } }
private async void Search(string st, TimeSpan?timeout = null) { Log("Search"); var ssdp_data = new StringBuilder() .Append("M-SEARCH * HTTP/1.1").Append("\r\n") .Append("HOST: ").Append(MULTICAST_ADDRESS).Append(":").Append(SSDP_PORT.ToString()).Append("\r\n") .Append("MAN: ").Append("\"ssdp:discover\"").Append("\r\n") .Append("MX: ").Append(MX.ToString()).Append("\r\n") .Append("ST: ").Append(st).Append("\r\n") .Append("\r\n") .ToString(); var data_byte = Encoding.UTF8.GetBytes(ssdp_data); var timeout_called = false; #if WINDOWS_PHONE || DOT_NET var DD_Handler = new AsyncCallback(ar => { if (timeout_called) { return; } var req = ar.AsyncState as HttpWebRequest; try { var res = req.EndGetResponse(ar) as HttpWebResponse; using (var reader = new StreamReader(res.GetResponseStream(), Encoding.UTF8)) { try { var response = reader.ReadToEnd(); OnDiscovered(new DeviceDescriptionEventArgs(response)); var camera = AnalyzeDescription(response); if (camera != null) { OnDiscovered(new SonyCameraDeviceEventArgs(camera, req.RequestUri)); } } catch (Exception) { Log("Invalid XML"); //Invalid XML. } } } catch (WebException) { //Invalid DD location or network error. } }); var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); socket.SendBufferSize = data_byte.Length; var snd_event_args = new SocketAsyncEventArgs(); snd_event_args.RemoteEndPoint = new IPEndPoint(IPAddress.Parse(MULTICAST_ADDRESS), SSDP_PORT); snd_event_args.SetBuffer(data_byte, 0, data_byte.Length); var rcv_event_args = new SocketAsyncEventArgs(); rcv_event_args.SetBuffer(new byte[RESULT_BUFFER], 0, RESULT_BUFFER); var SND_Handler = new EventHandler <SocketAsyncEventArgs>((sender, e) => { if (e.SocketError == SocketError.Success && e.LastOperation == SocketAsyncOperation.SendTo) { try { socket.ReceiveBufferSize = RESULT_BUFFER; socket.ReceiveAsync(rcv_event_args); } catch (ObjectDisposedException) { Log("Socket is already disposed."); } } }); snd_event_args.Completed += SND_Handler; var RCV_Handler = new EventHandler <SocketAsyncEventArgs>((sender, e) => { if (e.SocketError == SocketError.Success && e.LastOperation == SocketAsyncOperation.Receive) { string result = Encoding.UTF8.GetString(e.Buffer, 0, e.BytesTransferred); //Log(result); GetDeviceDescriptionAsync(DD_Handler, result); try { socket.ReceiveAsync(e); } catch (ObjectDisposedException) { Log("Socket is already disposed."); } } }); rcv_event_args.Completed += RCV_Handler; socket.SendToAsync(snd_event_args); #elif WINDOWS_PHONE_APP || WINDOWS_APP || NETFX_CORE var handler = new TypedEventHandler <DatagramSocket, DatagramSocketMessageReceivedEventArgs>(async(sender, args) => { Log("Datagram message received"); if (timeout_called || args == null) { return; } string data; using (var reader = args.GetDataReader()) { data = reader.ReadString(reader.UnconsumedBufferLength); } Log(data); await GetDeviceDescriptionAsync(data, args.LocalAddress).ConfigureAwait(false); }); var adapters = await GetActiveAdaptersAsync().ConfigureAwait(false); await Task.WhenAll(adapters.Select(async adapter => { using (var socket = new DatagramSocket()) { socket.Control.DontFragment = true; socket.MessageReceived += handler; try { await socket.BindServiceNameAsync("", adapter); socket.JoinMulticastGroup(MULTICAST_HOST); using (var output = await socket.GetOutputStreamAsync(MULTICAST_HOST, SSDP_PORT.ToString())) { using (var writer = new DataWriter(output)) { writer.WriteBytes(data_byte); await writer.StoreAsync(); } } await Task.Delay((timeout == null) ? DEFAULT_TIMEOUT : timeout.Value).ConfigureAwait(false); Log("Search Timeout"); timeout_called = true; } catch (Exception e) { Log("Failed to send multicast: " + e.StackTrace); } finally { socket.MessageReceived -= handler; } } })).ConfigureAwait(false); #endif #if WINDOWS_PHONE || DOT_NET await Task.Delay((timeout == null)?DEFAULT_TIMEOUT : timeout.Value).ConfigureAwait(false); Log("Search Timeout"); timeout_called = true; snd_event_args.Completed -= SND_Handler; rcv_event_args.Completed -= RCV_Handler; socket.Close(); #endif OnTimeout(new EventArgs()); }