public EndReceive ( IAsyncResult asyncResult, IPEndPoint &remoteEP ) : byte[] | ||
asyncResult | IAsyncResult | |
remoteEP | IPEndPoint | |
return | byte[] |
private void OnReceived(IAsyncResult ar) { if (Client != null) { IPEndPoint endpoint = new IPEndPoint((EndPoint as IPEndPoint).Address, 0); byte[] data; try { data = Client.EndReceive(ar, ref endpoint); } catch (SocketException) { Dispose(); return; } catch (ObjectDisposedException) { Dispose(); return; } LastActivity = DateTime.UtcNow; Client.BeginReceive(new AsyncCallback(OnReceived), null); Reader.ReceivedData(data); } }
//データを受信した時 private void ReceiveCallback(IAsyncResult ar) { System.Net.Sockets.UdpClient udp = (System.Net.Sockets.UdpClient)ar.AsyncState; //非同期受信を終了する System.Net.IPEndPoint remoteEP = null; byte[] rcvBytes; try { rcvBytes = udp.EndReceive(ar, ref remoteEP); } catch (System.Net.Sockets.SocketException ex) { Console.WriteLine("Error({0}/{1})", ex.Message, ex.ErrorCode); return; } catch (ObjectDisposedException ex) { //すでに閉じている時は終了 Console.WriteLine("Socket closed"); return; } //データを文字列に変換する string rcvMsg = System.Text.Encoding.UTF8.GetString(rcvBytes); var e = new UDP_ReceiveData(rcvMsg, remoteEP.Address.ToString()); Console.WriteLine("datarecived:{0}", rcvMsg); packet_receive(this, e); //再びデータ受信を開始する udp.BeginReceive(ReceiveCallback, udp); }
//データを受信した時 private void ReceiveCallback(IAsyncResult ar) { System.Net.Sockets.UdpClient udp = (System.Net.Sockets.UdpClient)ar.AsyncState; //非同期受信を終了する System.Net.IPEndPoint remoteEP = null; byte[] rcvBytes; try { rcvBytes = udp.EndReceive(ar, ref remoteEP); } catch (System.Net.Sockets.SocketException ex) { Console.WriteLine("受信エラー({0}/{1})", ex.Message, ex.ErrorCode); return; } catch (ObjectDisposedException ex) { //すでに閉じている時は終了 Console.WriteLine("Socketは閉じられています。"); return; } RecieveData(remoteEP.Address, remoteEP.Port, rcvBytes); //再びデータ受信を開始する udp.BeginReceive(ReceiveCallback, udp); }
public void ReceiveCallback(System.IAsyncResult ar) { System.Net.Sockets.UdpClient u = (System.Net.Sockets.UdpClient)((UdpState)(ar.AsyncState)).u; System.Net.IPEndPoint e = (System.Net.IPEndPoint)((UdpState)(ar.AsyncState)).e; var receiveBytes = u.EndReceive(ar, ref e); Debug.Log(BitConverter.ToString(receiveBytes)); int pos = 16; // 16バイトから開始 int width = 0; for (int i = 0; i < 4; i++) { width = width * 256 + receiveBytes[pos++]; } int height = 0; for (int i = 0; i < 4; i++) { height = height * 256 + receiveBytes[pos++]; } ReceiveBytes = receiveBytes; H = height; W = width; received = true; }
private void thread() { UdpClient ucl = new UdpClient(6000); IAsyncResult iar = ucl.BeginReceive(null, null); while (!exit) { if (!iar.AsyncWaitHandle.WaitOne(1000)) continue; IPEndPoint ep = new IPEndPoint(0, 0); byte[] data = ucl.EndReceive(iar, ref ep); iar = ucl.BeginReceive(null, 0); using (MemoryStream ms = new MemoryStream(data)) { BinaryReader br = new BinaryReader(ms); while (ms.Position < ms.Length) { CanMessage m = CanMessage.DeserializeFrom(br); if (MessageReceived != null) MessageReceived(this, m); } } } ucl.Close(); }
private void ReceiveCallBack(IAsyncResult Asr) { if (_udpClient == null) { return; } byte[] dat = null; try { dat = _udpClient.EndReceive(Asr, ref _receivedEp); } catch (SocketException ex) { return; } catch (ObjectDisposedException ex) { return; } OnBytesReceived?.Invoke(dat); if (OnBytesReceived == null) { // store the data if callback is not set _mutex.WaitOne(); _receivedPackets.AddLast(dat); _mutex.ReleaseMutex(); } // 今一度非同期受信を開始 _udpClient.BeginReceive(ReceiveCallBack, this); }
public static void ReceiveCallback(System.IAsyncResult ar) { System.Net.Sockets.UdpClient u = (System.Net.Sockets.UdpClient)((UdpState)(ar.AsyncState)).u; System.Net.IPEndPoint e = (System.Net.IPEndPoint)((UdpState)(ar.AsyncState)).e; var receiveBytes = u.EndReceive(ar, ref e); var receiveString = System.Text.Encoding.ASCII.GetString(receiveBytes); Debug.Log(string.Format("Received: {0}", receiveString)); // ここに任意の処理を書く received = true; }
private void ReceiveData(IAsyncResult ar) { try { System.Net.Sockets.UdpClient listener = (System.Net.Sockets.UdpClient)ar.AsyncState; byte[] data = listener.EndReceive(ar, ref endpoint); #endif if (data.Length < 16) { return;//bad request } UdpTrackerMessage request = UdpTrackerMessage.DecodeMessage(data, 0, data.Length, MessageType.Request); switch (request.Action) { case 0: ReceiveConnect((ConnectMessage)request); break; case 1: ReceiveAnnounce((AnnounceMessage)request); break; case 2: ReceiveScrape((ScrapeMessage)request); break; case 3: ReceiveError((ErrorMessage)request); break; default: throw new ProtocolException(string.Format("Invalid udp message received: {0}", request.Action)); } } catch (Exception e) { Logger.Log(null, e.ToString()); } finally { if (Running) { #if NETSTANDARD1_5 result = await listener.ReceiveAsync(); ReceiveData(result, client); #else listener.BeginReceive(new AsyncCallback(ReceiveData), listener); #endif } } }
private void OnPacketReceived(IAsyncResult ar) { if (udp != null) { lock (udp) { receivingPending = false; IPEndPoint remoteEP = null; try { byte[] bytes = udp.EndReceive(ar, ref remoteEP); if (bytes != null && bytes.Length > 0) { remoteEndPoint = remoteEP; lock (packets) { bool first = packets.Count == 0; packets.Add(bytes); if (first) { received.Set(); } } // begin another. if (udp != null) { receivingPending = true; udp.BeginReceive(new AsyncCallback(OnPacketReceived), this); } } } catch (SocketException ex) { // receive is forceably closed on send, so ignore that if (ex.SocketErrorCode != SocketError.ConnectionReset) { //throw; } } catch (Exception) { // perhaps it was closed... } } } }
private static IObservable<EmpegLocator> CreateResponseObservable(UdpClient client) { // Don't call BeginReceive until someone subscribes. return Observable.Defer( () => { IPEndPoint ep = null; var receive = Observable.FromAsyncPattern( client.BeginReceive, ar => client.EndReceive(ar, ref ep)); // Repeat will repeatedly subscribe; Defer will call receive() each time. return Observable.Defer(receive) .Where(bytes => bytes.Length != 1) .Select(bytes => EmpegLocator.Create(ep, bytes)) .Repeat(); }); }
void Recv(System.IAsyncResult Result) { byte[] Packet = null; // this func gets invoked when socket is shutdown if (Result != null && Socket != null) { // gr: does this throw if socket unreachable/closed? Packet = Socket.EndReceive(Result, ref EndPoint); } // immediately start begin waiting for next one (some stackoverflow posts suggests a gap can drop packets!?) if (Socket != null) { StartRecv(); } if (Packet != null) { this.OnPacket(Packet); } }
//データを受信した時 private void ReceiveCallback(IAsyncResult ar) { System.Net.Sockets.UdpClient udp = (System.Net.Sockets.UdpClient)ar.AsyncState; //非同期受信を終了する System.Net.IPEndPoint remoteEP = null; byte[] rcvBytes; try { rcvBytes = udp.EndReceive(ar, ref remoteEP); } catch (System.Net.Sockets.SocketException ex) { Console.WriteLine("受信エラー({0}/{1})", ex.Message, ex.ErrorCode); return; } catch (ObjectDisposedException ex) { //すでに閉じている時は終了 Console.WriteLine("Socketは閉じられています。"); return; } // 受信情報を控えておく(送信データに載せるため) // 受信データ lastRcvBytes_ = new byte[rcvBytes.Length]; Array.Copy(rcvBytes, 0, lastRcvBytes_, 0, rcvBytes.Length); // 受信元 lastRemoteEP_ = remoteEP; // 転送する SendUDP(sendIPAddress_, sendPort_); // 送信先に転送する場合 //再びデータ受信を開始する udp.BeginReceive(ReceiveCallback, udp); }
private void thread() { using (UdpClient ucl = new UdpClient(6000)) { IAsyncResult iar = ucl.BeginReceive(null, null); while (!exit) { WaitHandle.WaitAny(new [] { evt, iar.AsyncWaitHandle }); if (exit) break; IPEndPoint ep = new IPEndPoint(0, 0); byte[] data = ucl.EndReceive(iar, ref ep); iar = ucl.BeginReceive(null, 0); Boards.GetOrAdd(ep, e => new BoardInfo(e)).ParseMessage(data); } ucl.Close(); } }
private void ReceiveCallback(IAsyncResult ar) { try { // Retrieve the state object and the client socket // from the asynchronous state object. StateObject state = (StateObject)ar.AsyncState; System.Net.Sockets.UdpClient client = state.workSocket; // Read data from the remote device. byte[] bytesRead = client.EndReceive(ar, ref localEP); if (bytesRead.Length > 0) { byte[] rd = new byte[bytesRead.Length]; Array.Copy(bytesRead, 0, rd, 0, bytesRead.Length); if (MessageReceived != null) { MessageReceived(rd); } // Signal that all bytes have been received. receiveDone.Set(); // Continue receiving data. client.BeginReceive(new AsyncCallback(ReceiveCallback), state); } else { Disconnect(); } } catch (Exception e) { Console.WriteLine(e.ToString()); } }
/* * @brief ReceiveEndProc * @param[in] IAsyncResult ar * @return none * @note 受信完了時にcallback される関数 * 受信待機中に強制停止(Close()された場合もcallされる */ private void ReceiveEndProc(IAsyncResult ar) { System.Net.Sockets.UdpClient udp = (System.Net.Sockets.UdpClient)ar.AsyncState; //非同期受信を終了 System.Net.IPEndPoint remoteEndPt = null; byte[] rcvBytes; try { rcvBytes = udp.EndReceive(ar, ref remoteEndPt); } catch (System.Net.Sockets.SocketException ex) { Console.WriteLine("receive error.", ex.Message, ex.ErrorCode); return; } catch (ObjectDisposedException ex) { //すでに閉じている時は終了 string errStr = ex.Message; Console.WriteLine("Closed socket."); return; } //データを文字列に変換する //string rcvStr = System.Text.Encoding.UTF8.GetString(rcvBytes); string rcvStr = Encoding.ASCII.GetString(rcvBytes); // 本クラス使用元に 受信データ送信 upper_function(rcvStr); if (rcvUdp != null) { rcvUdp.Close(); } rcvUdp = null; }
/// <summary> /// Attemps to discover the server within a local network /// </summary> public void FindServer(Action<IPEndPoint> onSuccess) { // Create a udp client var client = new UdpClient(new IPEndPoint(IPAddress.Any, GetRandomUnusedPort())); // Construct the message the server is expecting var bytes = Encoding.UTF8.GetBytes(broadcastDiscoverMessage); // Send it - must be IPAddress.Broadcast, 7359 var targetEndPoint = new IPEndPoint(IPAddress.Broadcast, 7359); // Send it client.BeginSend(bytes, bytes.Length, targetEndPoint, iac => { //client.EndReceive client.BeginReceive(iar => { IPEndPoint remoteEndPoint= null; var result = client.EndReceive(iar, ref remoteEndPoint); if (remoteEndPoint.Port == targetEndPoint.Port) { // Convert bytes to text var text = Encoding.UTF8.GetString(result); // Expected response : MediaBrowserServer|192.168.1.1:1234 // If the response is what we're expecting, proceed if (text.StartsWith("mediabrowserserver", StringComparison.OrdinalIgnoreCase)) { text = text.Split('|')[1]; var vals = text.Split(':'); onSuccess(new IPEndPoint(IPAddress.Parse(vals[0]), int.Parse(vals[1]))); } } }, client); }, client); }
/// <summary> /// Looks up a record in DNS. /// </summary> /// <param name="name">The name to lookup</param> /// <param name="type">The type of record requested</param> /// <returns>The records returned by the DNS server, if any</returns> public override ResourceRecord[] Lookup(string name, RecordType type) { ushort transactionId = _nextTransId++; string normName = NormalizeDomainName(name); using (UdpClient udpClient = new UdpClient(0)) { IAsyncResult result = udpClient.BeginReceive(null, null); PacketWriter writer = new PacketWriter(1800); Message msg = new Message(); msg.TransactionId = transactionId; msg.Flags = new MessageFlags(false, OpCode.Query, false, false, false, false, ResponseCode.Success); msg.Questions.Add(new Question() { Name = normName, Type = type, Class = RecordClass.Internet }); msg.WriteTo(writer); byte[] msgBytes = writer.GetBytes(); foreach (var server in _servers) { udpClient.Send(msgBytes, msgBytes.Length, server); } for (int i = 0; i < maxRetries; ++i) { DateTime now = DateTime.UtcNow; while (result.AsyncWaitHandle.WaitOne(Math.Max(responseTimeout - (DateTime.UtcNow - now).Milliseconds, 0))) { try { IPEndPoint sourceEndPoint = null; byte[] packetBytes = udpClient.EndReceive(result, ref sourceEndPoint); PacketReader reader = new PacketReader(packetBytes); Message response = Message.Read(reader); if (response.TransactionId == transactionId) { return response.Answers.ToArray(); } } catch { // Do nothing - bad packet (probably...) } } } } return null; }
private void OnReceiveData(IAsyncResult asyncResult) { System.Net.Sockets.UdpClient conn = (System.Net.Sockets.UdpClient)asyncResult.AsyncState; try { System.Net.IPEndPoint ep = new IPEndPoint(System.Net.IPAddress.Any, 0); byte[] local_buffer; int rx = 0; try { local_buffer = conn.EndReceive(asyncResult, ref ep); rx = local_buffer.Length; } catch (Exception) // ICMP port unreachable { //restart data receive conn.BeginReceive(OnReceiveData, conn); return; } if (rx < 14) // Sure it's too small { //restart data receive conn.BeginReceive(OnReceiveData, conn); return; } try { int Offset = 0; Encapsulation_Packet Encapacket = new Encapsulation_Packet(local_buffer, ref Offset, rx); //verify message if (Encapacket.IsOK) { if (EncapMessageReceived != null) { EncapMessageReceived(this, local_buffer, Encapacket, Offset, rx, ep); } } else { SequencedAddressItem Itempacket = new SequencedAddressItem(local_buffer, ref Offset, rx); if (Itempacket.IsOK && (ItemMessageReceived != null)) { ItemMessageReceived(this, local_buffer, Itempacket, Offset, rx, ep); } } } catch (Exception ex) { Trace.TraceError("Exception in udp recieve: " + ex.Message); } finally { //restart data receive conn.BeginReceive(OnReceiveData, conn); } } catch (Exception ex) { //restart data receive if (conn.Client != null) { Trace.TraceError("Exception in Ip OnRecieveData: " + ex.Message); conn.BeginReceive(OnReceiveData, conn); } } }
public static bool ScanGrainBrains() { bool ret = false; var Client = new UdpClient(); var ServerEp = new IPEndPoint(IPAddress.Any, 8888); var raw = new byte[1024]; NetworkDiscoveryRequest request = new NetworkDiscoveryRequest(); request.Name = "NETWORK-DISCOVERY-MSG"; var ms = new MemoryStream(); request.WriteTo(ms); Client.EnableBroadcast = true; Client.Send(ms.GetBuffer(), (int)ms.Length, new IPEndPoint(IPAddress.Broadcast, 8888)); var rawr = new byte[15000]; var AsyncResponseData = Client.BeginReceive(null, null); int timeToWait = 1000; AsyncResponseData.AsyncWaitHandle.WaitOne(timeToWait); if (AsyncResponseData.IsCompleted) { try { byte[] receivedData = Client.EndReceive(AsyncResponseData, ref ServerEp); //Receive(ref ServerEp); var msr = new MemoryStream(receivedData); NetworkDiscoveryReply reply = new NetworkDiscoveryReply(); reply.MergeDelimitedFrom(msr); Console.Out.WriteLine("Grainbrain is found at {0}", ServerEp.Address); ipAddr = ServerEp.Address; ret = true; // EndReceive worked and we have received data and remote endpoint } catch (Exception ex) { Console.WriteLine("Caught exception {0}", ex); // EndReceive failed and we ended up here } } else { // The operation wasn't completed before the timeout and we're off the hook } Client.Close(); if (ret) updateStatus(); return ret; }
public void Test() { System.Net.Sockets.UdpClient cli = new System.Net.Sockets.UdpClient(11000); cli.BeginReceive(new AsyncCallback(x => { }), null); cli.BeginReceive(new AsyncCallback(x => { IPEndPoint ep = null; var ret = cli.EndReceive(x, ref ep); }), null); }
public Task<DateTime> GetDateAsync() { index++; if (hosts.Length <= index) { throw new InvalidOperationException( "After trying out all the hosts, was unable to find anyone that could tell us what the time is"); } var host = hosts[index]; return Task.Factory.FromAsync<IPAddress[]>((callback, state) => Dns.BeginGetHostAddresses(host, callback, state), Dns.EndGetHostAddresses, host) .ContinueWith(hostTask => { if (hostTask.IsFaulted) { log.DebugException("Could not get time from: " + host, hostTask.Exception); return GetDateAsync(); } var endPoint = new IPEndPoint(hostTask.Result[0], 123); var socket = new UdpClient(); socket.Connect(endPoint); socket.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 500); socket.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 500); var sntpData = new byte[SntpDataLength]; sntpData[0] = 0x1B; // version = 4 & mode = 3 (client) return Task.Factory.FromAsync<int>( (callback, state) => socket.BeginSend(sntpData, sntpData.Length, callback, state), socket.EndSend, null) .ContinueWith(sendTask => { if (sendTask.IsFaulted) { try { socket.Close(); } catch (Exception) { } log.DebugException("Could not send time request to : " + host, sendTask.Exception); return GetDateAsync(); } return Task.Factory.FromAsync<byte[]>(socket.BeginReceive, (ar) => socket.EndReceive(ar, ref endPoint), null) .ContinueWith(receiveTask => { if (receiveTask.IsFaulted) { try { socket.Close(); } catch (Exception) { } log.DebugException("Could not get time response from: " + host, receiveTask.Exception); return GetDateAsync(); } var result = receiveTask.Result; if (IsResponseValid(result) == false) { log.Debug("Did not get valid time information from " + host); return GetDateAsync(); } var transmitTimestamp = GetTransmitTimestamp(result); return new CompletedTask<DateTime>(transmitTimestamp); }).Unwrap(); }).Unwrap(); }).Unwrap(); }
public string[] UdpGetInfoByIPPort(string ipAddress, int ipPort, string cmdstr, int idelay, ref string state) { if (basefun.IsCorrenctIP(ipAddress) == false) return null; if (idelay == 0) idelay = 100; int timeout = idelay; byte[] bytOutBuffer = getByteBy16s(cmdstr); IPEndPoint RemoteIpEndPoint = SetIPEndPoint(ipAddress, ipPort); byte[] bytReceiveBuffer; using (UdpClient udpClient = new UdpClient()) { udpClient.Send(bytOutBuffer, bytOutBuffer.Length, RemoteIpEndPoint); IPEndPoint from = new IPEndPoint(IPAddress.Any, 0); IAsyncResult result = udpClient.BeginReceive(null, this); result.AsyncWaitHandle.WaitOne(timeout, false); if (!result.IsCompleted) { //throw SharpTimeoutException.Create(ipAddress, timeout); udpClient.Close(); return null; } bytReceiveBuffer = udpClient.EndReceive(result, ref from); string udpInfo = get16sByByte(bytReceiveBuffer); udpInfo = SpecialRestore(udpInfo, "dddb", "db"); udpInfo = SpecialRestore(udpInfo, "dcdb", "c0"); //ȡ����ֵ16��������,������ string[] infos = AnalysisEateryResults(udpInfo, ref state); udpClient.Close(); return infos; } }
public string GetInfo(string devpms, string cmdpms, string datapms, string OutString, ref string state, ref string cmdstring) { devObj devobj = new devObj(); string cmdstr = CommandString(devpms, cmdpms, datapms, ref devobj); if (basefun.IsCorrenctIP(devobj.IP) == false) return null; if (devobj.Delay == 0) devobj.Delay = 2000; byte[] bytOutBuffer; if (devobj.IsAsc) { string strhead = cmdstr.Substring(0, 2); string strend = cmdstr.Substring(cmdstr.Length - 2, 2); cmdstr = cmdstr.Substring(2, cmdstr.Length - 2); cmdstr = cmdstr.Substring(0, cmdstr.Length - 2); bytOutBuffer = getAscByteBy16s(cmdstr, strhead, strend); } else bytOutBuffer = getByteBy16s(cmdstr); IPEndPoint RemoteIpEndPoint = SetIPEndPoint(devobj.IP, basefun.toIntval(devobj.Port), devobj.Mode); byte[] bytReceiveBuffer; using (UdpClient udpClient = new UdpClient()) { udpClient.Send(bytOutBuffer, bytOutBuffer.Length, RemoteIpEndPoint); IPEndPoint from = new IPEndPoint(IPAddress.Any, 0); IAsyncResult result = udpClient.BeginReceive(null, this); result.AsyncWaitHandle.WaitOne(devobj.Delay, false); if (!result.IsCompleted) { udpClient.Close(); return null; } bytReceiveBuffer = udpClient.EndReceive(result, ref from); string udpInfo = ""; if (devobj.IsAsc) { string info = ""; char[] cbuff = new char[bytReceiveBuffer.Length - 2]; for (int i = 1; i < bytReceiveBuffer.Length - 1; i++) { cbuff[i - 1] = (char)bytReceiveBuffer[i]; info += Convert.ToString(cbuff[i - 1]); } //ȥ��֡ͷ��֡β udpInfo = info; } else udpInfo = get16sByByte(bytReceiveBuffer, true); //�ָ�ת���ַ� if (devobj.Exchanges != "") { string[] strExs = devobj.Exchanges.Split('#'); for (int i = 0; i < strExs.Length; i++) { string[] _a = strExs[i].Split('/'); udpInfo = SpecialRestore(udpInfo, _a[1], _a[0]); } } //ȡ����ֵ16��������,������ //udpInfo = "7E7AF08110091227000012200100000000DCDE0F909B137D0100FF00000000F4060D"; string infos = AnalysisEateryResults(udpInfo, OutString, devobj, true, ref state); udpClient.Close(); return infos; } }
static void DoReceive(UdpClient udpClient, byte[] rgbSent, List<KnownNXT> result, SamanthaDiscovery discParam) { udpClient.BeginReceive((IAsyncResult ar) => { // // Program.Trace("IPConnection.DoReceive"); // SamanthaDiscovery disc = ar.AsyncState as SamanthaDiscovery; lock (disc) { if (!disc.fCanceled) { // Get the bytes for the incoming packet IPEndPoint epSender = null; byte[] rgbReceived = udpClient.EndReceive(ar, ref epSender); // Post another request so we see all responses DoReceive(udpClient, rgbSent, result, discParam); // Note that we see our own initial transmission as well as responses from // actual Samantha modules. We'd like to distinguish the former as being // send to the broadcast address, but it doesn't appear that we can get that // info here. So we just compare to the packet we sent. if (rgbSent.IsEqualTo(rgbReceived)) { // It's just us Program.Trace("samantha: saw our packet"); } else { // It's a Samantha. The address of the Samantha we get from udpClient. The // payload, though isn't especially useful to us: it appears to be two text lines // followed by a one-byte status code. The first line seems to be the Netbios name // by which we could locate the module, and the second is a text form of the module's // MAC address. Observed values for the status are 'A' for active, and 'O' for // offline. So we'll just snarf the address away and go through the ProbeForNXT logic later // like the other connection types. // // Update: we actually want to dig the name string out and parse it. May as well, just // in case the ProbeForNXT doesn't find anything. // Program.Trace("samantha: saw {0}", epSender.Address.ToString()); string sReceived = (new System.Text.ASCIIEncoding()).GetString(rgbReceived); string[] lines = sReceived.Lines(StringSplitOptions.RemoveEmptyEntries); // First three chars are 'NXT' prepended to the actual NXT name. So a brick named 'Foo' // will show up as 'NXTFoo'. string sNXT = lines[0].SafeSubstring(3).Trim(); lock (result) // the delegate is called on a worker thread with (to us) unknown concurrency { KnownNXT.AddKnownNXT(result, new KnownNXT(KnownNXT.CONNECTIONTYPE.IP, epSender.Address.ToString(), sNXT)); } } } } }, discParam); }
//データを受信した時 private void ReceiveCallback(IAsyncResult ar) { System.Net.Sockets.UdpClient udp = (System.Net.Sockets.UdpClient)ar.AsyncState; //非同期受信を終了する System.Net.IPEndPoint remoteEP = null; byte[] rcvBytes; try { rcvBytes = udp.EndReceive(ar, ref remoteEP); } catch (System.Net.Sockets.SocketException ex) { Console.WriteLine("受信エラー({0}/{1})", ex.Message, ex.ErrorCode); return; } catch (ObjectDisposedException ex) { //すでに閉じている時は終了 Console.WriteLine("Socketは閉じられています。"); return; } // 処理対象? DhcpPacket rcv_packet = new DhcpPacket(rcvBytes); Boolean reply = this.dhcplease_.AutoReply(rcv_packet.chaddr_); Boolean match = this.dhcplease_.Matches(rcv_packet.chaddr_); { // 受信情報を控えておく(送信データに載せるため) // 受信データ lastRcvBytes_ = new byte[rcvBytes.Length]; Array.Copy(rcvBytes, 0, lastRcvBytes_, 0, rcvBytes.Length); // 受信元 lastRemoteEP_ = remoteEP; } //データを文字列に変換する string rcvMsg = "0x" + rcv_packet.xid_.ToString("X4") + ", " + rcv_packet.message_type_; //受信したデータと送信者の情報をRichTextBoxに表示する string displayMsg = string.Format("{0} [{1} ({2})] < {3}", DateTime.Now.ToString("HH:mm:ss.fff"), remoteEP.Address, remoteEP.Port, rcvMsg); textBoxRcvData.BeginInvoke( new Action <string>(ShowReceivedString), displayMsg); // 応答する if (match && (!reply)) { // 当該MACアドレスが登録されていて、 // かつ、「自動応答」が明示的にOFFされている場合は応答しない } else { // それ以外は応答する // 送信先のIPアドレスは remoteEP.Address ではなく、ブロードキャスト SendUDP(sourceIPAddress_, sourcePort_, IPAddress.Broadcast, remoteEP.Port); } //再びデータ受信を開始する udp.BeginReceive(ReceiveCallback, udp); }
public static IPAddress GetPublicIPAddress(string stunServer) { try { logger.Debug("STUNClient attempting to determine public IP from " + stunServer + "."); using (UdpClient udpClient = new UdpClient(stunServer, m_defaultSTUNPort)) { STUNMessage initMessage = new STUNMessage(STUNMessageTypesEnum.BindingRequest); byte[] stunMessageBytes = initMessage.ToByteBuffer(); udpClient.Send(stunMessageBytes, stunMessageBytes.Length); IPAddress publicIPAddress = null; ManualResetEvent gotResponseMRE = new ManualResetEvent(false); udpClient.BeginReceive((ar) => { try { IPEndPoint stunResponseEndPoint = null; byte[] stunResponseBuffer = udpClient.EndReceive(ar, ref stunResponseEndPoint); if (stunResponseBuffer != null && stunResponseBuffer.Length > 0) { logger.Debug("STUNClient Response to initial STUN message received from " + stunResponseEndPoint + "."); STUNMessage stunResponse = STUNMessage.ParseSTUNMessage(stunResponseBuffer, stunResponseBuffer.Length); if (stunResponse.Attributes.Count > 0) { foreach (STUNAttribute stunAttribute in stunResponse.Attributes) { if (stunAttribute.AttributeType == STUNAttributeTypesEnum.MappedAddress) { publicIPAddress = ((STUNAddressAttribute)stunAttribute).Address; logger.Debug("STUNClient Public IP=" + publicIPAddress.ToString() + "."); } } } } gotResponseMRE.Set(); } catch (Exception recvExcp) { logger.Warn("Exception STUNClient Receive. " + recvExcp.Message); } }, null); if (gotResponseMRE.WaitOne(STUN_SERVER_RESPONSE_TIMEOUT * 1000)) { return publicIPAddress; } else { logger.Warn("STUNClient server response timedout after " + STUN_SERVER_RESPONSE_TIMEOUT + "s."); return null; } } } catch (Exception excp) { logger.Error("Exception STUNClient GetPublicIPAddress. " + excp.Message); return null; //throw; } }
public string GetInfo(string devpms, string cmdpms, string datapms, string OutString, ref string state) { devObj devobj = new devObj(); string cmdstr = CommandString(devpms, cmdpms, datapms, ref devobj); if (basefun.IsCorrenctIP(devobj.IP) == false) return null; if (devobj.Delay == 0) devobj.Delay = 2000; byte[] bytOutBuffer; if (devobj.IsAsc) { string strhead = cmdstr.Substring(0, 2); string strend = cmdstr.Substring(cmdstr.Length - 2, 2); cmdstr = cmdstr.Substring(2, cmdstr.Length - 2); cmdstr = cmdstr.Substring(0, cmdstr.Length - 2); bytOutBuffer = getAscByteBy16s(cmdstr, strhead, strend); } else bytOutBuffer = getByteBy16s(cmdstr); //string strasc = ""; //for (int i = 0; i < bytOutBuffer.Length; i++) //{ // strasc = bytOutBuffer[i]. //} byte[] bytReceiveBuffer; //----- UDP ------// if (devobj.Mode == 0) { SerialCommi serialcom = new SerialCommi(); serialcom.SetProtocolParam("COM1", devobj.baudRate, devobj.Delay); bytReceiveBuffer = serialcom.SendCommand(cmdstr,true); } else { IPEndPoint RemoteIpEndPoint = SetIPEndPoint(devobj.IP, basefun.toIntval(devobj.Port), devobj.Mode); UdpClient udpClient = new UdpClient(); udpClient.Send(bytOutBuffer, bytOutBuffer.Length, RemoteIpEndPoint); IPEndPoint from = new IPEndPoint(IPAddress.Any, 0); IAsyncResult result = udpClient.BeginReceive(null, this); result.AsyncWaitHandle.WaitOne(devobj.Delay, false); if (!result.IsCompleted) { udpClient.Close(); return null; } bytReceiveBuffer = udpClient.EndReceive(result, ref from); udpClient.Close(); } //----------------- string udpInfo = ""; if (devobj.IsAsc) { string info = ""; char[] cbuff = new char[bytReceiveBuffer.Length - 2]; for (int i = 1; i < bytReceiveBuffer.Length - 1; i++) { cbuff[i - 1] = (char)bytReceiveBuffer[i]; info += Convert.ToString(cbuff[i - 1]); } //去掉帧头和帧尾 udpInfo = info; } else udpInfo = get16sByByte(bytReceiveBuffer, true); //恢复转义字符 if (devobj.Exchanges != "") { string[] strExs = devobj.Exchanges.Split('#'); for (int i = 0; i < strExs.Length; i++) { string[] _a = strExs[i].Split('/'); udpInfo = SpecialRestore(udpInfo, _a[1], _a[0]); } } //取返回值16进制数组,并解析 string infos = AnalysisEateryResults(udpInfo, OutString, devobj, true, ref state); return infos; }
private void Callback(IAsyncResult result) { try { UdpBroadcastMessage message = null; IPEndPoint ep = mBroadcastEp; using (MemoryStream ms = new MemoryStream(mUdpClient.EndReceive(result, ref ep))) { ms.Position = 0; message = mMessageFormatter.Read(ms); ms.SetLength(0); } if (LOGGER.IsInfoEnabled) { LOGGER.Info(string.Format("BROADCAST_SERVER, a broadcast message arrived from '{0}'.", message.SenderId)); } if (NetworkManager.Instance.InternalLocalhost.Id.Equals(message.SenderId)) { if (LOGGER.IsInfoEnabled) { LOGGER.Info("BROADCAST_SERVER, this broadcast message arrived from me."); } } else { if (NetworkManager.Instance.NetworkContextRuleManager.CheckSeparation(NetworkManager.Instance.InternalLocalhost.NetworkContext.Name, message.NetworkContextName)) { // láthatom ezt a context-et, megpróbálok rácsatlakozni INetworkPeerRemote peer = NetworkPeerContext.GetNetworkPeerById(message.SenderId); if (peer == null || (peer != null && peer.Distance != 1)) { // nincs közvetlen kapcsolatom ilyen peer-el mThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(ConnectionTask), message); } else { if (LOGGER.IsInfoEnabled) { LOGGER.Info(string.Format("BROADCAST_SERVER, this is a known peer with direct network connection. No need to establish a new. PeerId: '{0}'.", peer.Id)); } } } else { if (LOGGER.IsInfoEnabled) { LOGGER.Info(string.Format("BROADCAST_SERVER, network context separation is active between '{0}' and '{1}'.", NetworkManager.Instance.InternalLocalhost.NetworkContext.Name, message.NetworkContextName)); } } } } catch (Exception ex) { if (LOGGER.IsErrorEnabled) { LOGGER.Error(string.Format("BROADCAST_SERVER, failed to receive a broadcast message. Reason: {0}", ex.Message)); } } finally { BeginReceive(); } }
void IProxy.LaunchProxy() { if (_alreadyCalledProxyMethod) { return; } _alreadyCalledProxyMethod = true; try { UdpClient client = new UdpClient(_src); Socket server = new Socket( AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); // --- AsyncCallback clientCallback = null; AsyncCallback serverCallback = null; // TODO: Only done once ... even so, put his in assync! :D server.Connect(_target); serverCallback = delegate(IAsyncResult res) { SocketError err = default(SocketError); int bytes = server.EndSend(res, out err); // Check if all was sent ... if (err == SocketError.Success) { Trace.WriteLine(string.Format("Sent {0} bytes to server.", bytes)); } else { Trace.WriteLine(string.Format("Error {0} on sending", err)); } }; clientCallback = delegate(IAsyncResult res) { // Reattach listener asap client.BeginReceive(clientCallback, client); byte[] datagram = client.EndReceive(res, ref _src); Trace.WriteLine(string.Format("Received {0} bytes from client.", datagram.Length)); // Send to target Trace.WriteLine(string.Format("About to send {0} bytes to server", datagram.Length)); server.BeginSend( datagram, 0, datagram.Length, SocketFlags.None, serverCallback, server); // -- }; IAsyncResult result = client.BeginReceive(clientCallback, client); } catch (Exception e) { throw e; // TODO: Better exception message ... //Trace.WriteLine("Exception at UdpProxy: " + e.Message); } }
// Wiresharkの表示を参考にした public static XmlDocument Query(IPEndPoint ip, int millisecs) { using (UdpClient client = new UdpClient(ip.AddressFamily)) { client.Connect(ip); Random rand = new Random(); ushort seed = (ushort)rand.Next(); { MemoryStream os = new MemoryStream(); BEW wr = new BEW(os); wr.Write(seed); wr.Write((ushort)0);//Flags: 0x0000 (Name query) wr.Write((ushort)1);//Questions: 1 wr.Write((ushort)0);//Answer RRs: 0 wr.Write((ushort)0);//Authority RRs: 0 wr.Write((ushort)0);//Additional RRs: 0 wr.Write((byte)32); wr.Write(Encoding.ASCII.GetBytes("CKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")); wr.Write((byte)0); wr.Write((ushort)0x21);//Type: NBSTAT wr.Write((ushort)0x01);//Class: IN byte[] bin = os.ToArray(); if (client.Send(bin, bin.Length) != bin.Length) throw new EndOfStreamException(); } { XmlDocument xmlo = new XmlDocument(); XmlElement elroot = xmlo.CreateElement("wins"); xmlo.AppendChild(elroot); XmlElement elres = xmlo.CreateElement("response"); elroot.AppendChild(elres); byte[] bin; { IPEndPoint ipr = new IPEndPoint(0, 0); IAsyncResult ar = client.BeginReceive(CbReceived, null); if (false == ar.AsyncWaitHandle.WaitOne(millisecs, false)) { client.Close(); } bin = client.EndReceive(ar, ref ipr); } MemoryStream si = new MemoryStream(bin, false); BER br = new BER(si); ushort rseed = br.ReadUInt16(); if (rseed != seed) throw new InvalidDataException(); ushort fl = br.ReadUInt16(); if (0 == (fl & 0x8000) || 0 != (fl & 15)) throw new InvalidDataException(); { int cnt = br.ReadUInt16(); for (int x = 0; x < cnt; ) { throw new NotSupportedException(); } } int[] acnt = new int[3]; acnt[0] = br.ReadUInt16(); acnt[1] = br.ReadUInt16(); acnt[2] = br.ReadUInt16(); for (int t = 0; t < 3; t++) { XmlElement elrrs = null; if (t == 0) elrrs = xmlo.CreateElement("answer-rrs"); if (t == 1) elrrs = xmlo.CreateElement("authority-rrs"); if (t == 2) elrrs = xmlo.CreateElement("additional-rrs"); elres.AppendChild(elrrs); for (int x = 0; x < acnt[t]; x++) { XmlElement ela = xmlo.CreateElement("answer"); elrrs.AppendChild(ela); byte cb = br.ReadByte(); byte[] name = br.ReadBytes(cb); ela.SetAttribute("raw-name", Encoding.ASCII.GetString(name)); byte nodeType = br.ReadByte(); ela.SetAttribute("node-type", nodeType.ToString("x2")); int atype = br.ReadUInt16(); if (atype != 0x21) throw new NotSupportedException(); int aclass = br.ReadUInt16(); if (aclass != 1) throw new NotSupportedException(); uint attl = br.ReadUInt32(); ela.SetAttribute("ttl", attl.ToString()); br.ReadUInt16(); byte aNamecnt = br.ReadByte(); for (int a = 0; a < aNamecnt; a++) { String aname = Encoding.Default.GetString(br.ReadBytes(15)); byte anty = br.ReadByte(); int afl = br.ReadUInt16(); XmlElement elan = xmlo.CreateElement("name"); ela.AppendChild(elan); elan.SetAttribute("name", aname); elan.SetAttribute("name-type", anty.ToString("x2")); elan.SetAttribute("flags", afl.ToString("x4")); } byte[] mac = br.ReadBytes(6); ela.SetAttribute("unit-id", String.Format("{0:x2}:{1:x2}:{2:x2}:{3:x3}:{4:x2}:{5:x2}" , mac[0] , mac[1] , mac[2] , mac[3] , mac[4] , mac[5] )); } } return xmlo; } } }