public AckListMessage(DatagramPacket dp) { this.dp = dp; dpData = dp.getData(); ver = ByteShortConvert.toShort(dpData, 0); sType = ByteShortConvert.toShort(dpData, 2); connectId = ByteIntConvert.toInt(dpData, 4); clientId = ByteIntConvert.toInt(dpData, 8); lastRead = ByteIntConvert.toInt(dpData, 4 + 8); int sum = ByteShortConvert.toShort(dpData, 8 + 8); ackList = new List <int>(); int t = 0; for (int i = 0; i < sum; i++) { t = 10 + 4 * i; int sequence = ByteIntConvert.toInt(dpData, t + 8); ackList.Add(sequence); } ////#MLog.println("LLLLLLLLLLLLLL "+dp.getLength()+" "+ackList.size()); t = 10 + 4 * sum - 4; r1 = ByteIntConvert.toInt(dpData, t + 4 + 8); s1 = ByteIntConvert.toInt(dpData, t + 8 + 8); r2 = ByteIntConvert.toInt(dpData, t + 12 + 8); s2 = ByteIntConvert.toInt(dpData, t + 16 + 8); r3 = ByteIntConvert.toInt(dpData, t + 20 + 8); s3 = ByteIntConvert.toInt(dpData, t + 24 + 8); ////#MLog.println("aaaaaaaaa"+r3+"kkkkkkk "+s3); }
/* (non-Javadoc) * @see java.net.DatagramSocket#send(java.net.DatagramPacket) */ /// <exception cref="System.IO.IOException"/> public override void Send(DatagramPacket p) { // capture the byte arrays byte[] bytes = new byte[p.GetLength()]; System.Array.Copy(p.GetData(), p.GetOffset(), bytes, 0, p.GetLength()); this.capture.AddItem(bytes); }
public override void Run() { while (running) { try { byte[] receiveData = new byte[RECEIVE_BUFFER_LENGTH]; DatagramPacket incomingPacket = new DatagramPacket(receiveData, receiveData.Length); socket.Receive(incomingPacket); System.Threading.Thread thread = new System.Threading.Thread(new ThreadStart(() => { if (receiveData[0] == RtpMidiCommand.MIDI_COMMAND_HEADER1) { midiCommandHandler.handle(receiveData, new model.RtpMidiServer(incomingPacket.Address, incomingPacket.Port)); } else { midiMessageHandler.Handle(receiveData, new RtpMidiServer(incomingPacket.Address.HostName, incomingPacket.Port)); } })); thread.Start(); } catch (SocketTimeoutException ignored) { } catch (IOException e) { Log.Error("RtpMidi", "IOException while receiving", e); } } socket.Close(); }
//UDP 송신. public static void udpSendByte(byte[] send_data) { //udpChannel 의 상태를 점검하여, 송신할 상황이 아니라면 종료. if (udpChannel == null || udpChannel.Active != true || udpChannel.IsWritable != true) { return; } try { //IByteBuffer 는, 자바 Netty 의 ByteBuf 와 같은 역할. //보낼 데이터릐 길이만큼, alloc 에서 DirectBuffer를 할당받아서 가져옴. IByteBuffer data = alloc.DirectBuffer(send_data.Length); //받아온 byte[] 데이터를, 할당받아온 IByteBuffer에 기록함. data.WriteBytes(send_data); //DotNetty에서 제공하는 DatagramPacket 객체를 꾸밈. //DatagramPacket 생성자 =>> new DatagramPacket(보낼 데이터(IByteBuffer), 보낸곳의 로컬 주소정보(udpChannel.LocalAddress), 보낼 목적지 주소정보(udpChannel.RemoteAddress)); DatagramPacket udp_data = new DatagramPacket(data, udpChannel.LocalAddress, udpChannel.RemoteAddress); //udpChannel 를 통해 해당 Datagram 데이터를 송신! udpChannel.WriteAndFlushAsync(udp_data); } catch (Exception e) { Debug.Log("udpSendByte() Error:" + e.ToString()); } }
public AckListPacket(DatagramPacket datagramPacket) { MyDatagramPacket = datagramPacket; DatagramData = datagramPacket.Data; Ver = BitConverter.ToInt16(DatagramData, 0); SType = BitConverter.ToInt16(DatagramData, 2); ConnectId = BitConverter.ToInt32(DatagramData, 4); ClientId = BitConverter.ToInt32(DatagramData, 8); LastRead = BitConverter.ToInt32(DatagramData, 12); int sum = BitConverter.ToInt16(DatagramData, 16); AckList = new List <int>(); int t = 0; for (int i = 0; i < sum; i += 1) { t = 10 + 4 + i; int sequence = BitConverter.ToInt32(DatagramData, t + 8); AckList.Add(sequence); } t = 10 + 4 * sum - 4; R1 = BitConverter.ToInt32(DatagramData, t + 4 + 8); S1 = BitConverter.ToInt32(DatagramData, t + 8 + 8); R2 = BitConverter.ToInt32(DatagramData, t + 12 + 8); S2 = BitConverter.ToInt32(DatagramData, t + 16 + 8); R3 = BitConverter.ToInt32(DatagramData, t + 20 + 8); S3 = BitConverter.ToInt32(DatagramData, t + 24 + 8); }
//UDP 데이터 수신시. public override void ChannelRead(IChannelHandlerContext context, object message) { //UDP 채널의 경우에는 DatagramPacket으로 받아온다. DatagramPacket msg = (DatagramPacket)message; //DatagramPacket 에서 IByteBuffer 데이터를 가져온다. IByteBuffer receive_data = msg.Content; //받아온 데이터 길이(receive_data.ReadableBytes) 만큼 byte[] 를 할당한다. byte[] recvData = new byte[receive_data.ReadableBytes]; //receive_data 로부터 recvData 에다가 데이터를 기록한다. recvData의 0번 위치부터 기록함. receive_data.ReadBytes(recvData, 0, receive_data.ReadableBytes); //받아온 데이터를 메인스레드와 통신하기 위한 목적으로 만들어둔 수신 Queue에 삽입. //멀티스레드에서 공유하는 Queue이므로, Locking 처리. NetworkManager.locking 는 스레드 lock용 모니터 객체이다. lock (NetworkManager.locking) { //데이터 삽입. NetworkManager.packet_Queue.Enqueue(new Packet_Data(recvData)); } //한번 할당받은 IByteBuffer 객체는 할당해제를 해줘야 한다. ReferenceCount가 0인 객체는 자동으로 반환되며, ReferenceCount가 0인 객체에 접근시 에러 발생! if (msg.ReferenceCount > 0) { ReferenceCountUtil.Release(msg); } }
public void StartListen() { // UDP服务器监听的端口 int port = 4000; // 接收的字节大小,客户端发送的数据不能超过这个大小 byte[] message = new byte[512]; DatagramSocket datagramSocket = new DatagramSocket(port); datagramSocket.Broadcast = true; DatagramPacket datagramPacket = new DatagramPacket(message, message.Length); try { while (!IsThreadDisable) { datagramSocket.Receive(datagramPacket); string strMsg = new Java.Lang.String(datagramPacket.GetData()).Trim(); string[] msg = strMsg.Split(new string[] { "\r\n" }, StringSplitOptions.None); } } catch (System.Exception e) { } }
public Ukcp get(DatagramPacket msg) { var conv = getConv(msg); _ukcps.TryGetValue(conv, out var ukcp); return(ukcp); }
// TODO: convert this to Junit internal static void TestRequest(XDR request, XDR request2) { try { DatagramSocket clientSocket = new DatagramSocket(); IPAddress IPAddress = Sharpen.Extensions.GetAddressByName("localhost"); byte[] sendData = request.GetBytes(); byte[] receiveData = new byte[65535]; DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.Length, IPAddress , Nfs3Constant.SunRpcbind); clientSocket.Send(sendPacket); DatagramPacket receivePacket = new DatagramPacket(receiveData, receiveData.Length ); clientSocket.Receive(receivePacket); clientSocket.Close(); } catch (UnknownHostException) { System.Console.Error.WriteLine("Don't know about host: localhost."); System.Environment.Exit(1); } catch (IOException) { System.Console.Error.WriteLine("Couldn't get I/O for " + "the connection to: localhost." ); System.Environment.Exit(1); } }
public override void run() { Console.WriteLine(string.Format("Starting AutoDetectJpcsp ListenerThread")); sbyte[] response = new sbyte[256]; while (!exit_Renamed) { try { InetAddress listenAddress = InetAddress.getByName(multicastIp); MulticastSocket socket = new MulticastSocket(discoveryPort); socket.joinGroup(listenAddress); while (!exit_Renamed) { DatagramPacket packet = new DatagramPacket(response, response.Length); socket.receive(packet); processRequest(socket, new string(packet.Data, packet.Offset, packet.Length), packet.Address, packet.Port); } socket.close(); } catch (IOException e) { Console.WriteLine("ListenerThread", e); exit(); } } }
public override async Task DoReceiveMessageAsync() { // receive bytes UdpReceiveResult udpRes; try { udpRes = await _udpClient.ReceiveAsync().WithCancellation(CloseToken); } catch (OperationCanceledException) { // the socket has been closed return; } var buf = AlternativeCompositeByteBuf.CompBuffer(); buf.WriteBytes(udpRes.Buffer.ToSByteArray()); var localEp = (IPEndPoint)Socket.LocalEndPoint; RemoteEndPoint = udpRes.RemoteEndPoint; var dgram = new DatagramPacket(buf, localEp, RemoteEndPoint); Logger.Debug("Received {0}. {1} : {2}", dgram, Convenient.ToHumanReadable(udpRes.Buffer.Length), Convenient.ToString(udpRes.Buffer)); // execute inbound pipeline if (Session.IsTimedOut) { return; } Session.Read(dgram); Session.Reset(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void processRequest(java.net.MulticastSocket socket, String request, java.net.InetAddress address, int port) throws java.io.IOException internal virtual void processRequest(MulticastSocket socket, string request, InetAddress address, int port) { Console.WriteLine(string.Format("Received '{0}' from {1}:{2:D}", request, address, port)); Regex p = Pattern.compile("SEARCH +\\* +.*^ST: *" + deviceName + "$.*", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL); Matcher m = p.matcher(request); if (m.find()) { StringBuilder response = new StringBuilder(); int netServerPortShift = Modules.sceNetAdhocModule.getRealPortFromServerPort(0); if (netServerPortShift == 0) { // Set a default server port shift if none has been set. netServerPortShift = 100; Modules.sceNetAdhocModule.NetServerPortShift = netServerPortShift; Modules.sceNetAdhocModule.NetClientPortShift = 0; } response.Append(string.Format("Location: {0}:{1:D}", LocalHostIP, netServerPortShift)); Console.WriteLine(string.Format("Sending response '{0}' to {1}:{2:D}", response, address, port)); DatagramPacket packet = new DatagramPacket(response.ToString().GetBytes(), response.Length, address, port); socket.send(packet); } }
public virtual void discover() { try { igd = new IGD(); ListenerThread listener = new ListenerThread(this, igd); listener.Daemon = true; listener.Name = "UPnP Discovery Listener"; listener.Start(); while (!listener.Ready) { Utilities.sleep(100); } foreach (string device in deviceList) { string discoveryRequest = string.Format("M-SEARCH * HTTP/1.1\r\nHOST: {0}:{1:D}\r\nST: {2}\r\nMAN: \"ssdp:discover\"\r\nMX: {3:D}\r\n\r\n", multicastIp, discoveryPort, device, discoveryTimeoutMillis / 1000); IEnumerator <NetworkInterface> networkInterfaces = NetworkInterface.NetworkInterfaces; while (networkInterfaces.MoveNext()) { NetworkInterface networkInterface = networkInterfaces.Current; if (networkInterface.Up && networkInterface.supportsMulticast()) { for (IEnumerator <InetAddress> addresses = networkInterface.InetAddresses; addresses.MoveNext();) { InetAddress address = addresses.Current; if (address is Inet4Address && !address.LoopbackAddress) { MulticastSocket socket = new MulticastSocket(new InetSocketAddress(address, discoverySearchPort)); InetSocketAddress socketAddress = new InetSocketAddress(multicastIp, discoveryPort); DatagramPacket packet = new DatagramPacket(discoveryRequest.GetBytes(), discoveryRequest.Length, socketAddress); socket.send(packet); socket.disconnect(); socket.close(); } } } } } for (int i = 0; i < discoveryTimeoutMillis / 10; i++) { if (listener.Done) { break; } Utilities.sleep(10, 0); } listener.Done = true; while (!listener.Ready) { Utilities.sleep(100); } } catch (IOException e) { Console.WriteLine("discover", e); } }
/// <summary>Sends Ganglia Metrics to the configured hosts</summary> /// <exception cref="System.IO.IOException"/> protected internal virtual void EmitToGangliaHosts() { try { foreach (EndPoint socketAddress in metricsServers) { if (socketAddress == null || !(socketAddress is IPEndPoint)) { throw new ArgumentException("Unsupported Address type"); } IPEndPoint inetAddress = (IPEndPoint)socketAddress; if (inetAddress.IsUnresolved()) { throw new UnknownHostException("Unresolved host: " + inetAddress); } DatagramPacket packet = new DatagramPacket(buffer, offset, socketAddress); datagramSocket.Send(packet); } } finally { // reset the buffer for the next metric to be built offset = 0; } }
private void sendPacket(sbyte[] buffer, int bufferLength) { //if (log.DebugEnabled) { Console.WriteLine(string.Format("sendPacket {0}", Utilities.getMemoryDump(buffer, 0, bufferLength))); } try { InetSocketAddress[] broadcastAddress = sceNetInet.getBroadcastInetSocketAddress(BroadcastPort); if (broadcastAddress != null) { for (int i = 0; i < broadcastAddress.Length; i++) { DatagramPacket packet = new DatagramPacket(buffer, bufferLength, broadcastAddress[i]); apSocket.send(packet); } } } catch (UnknownHostException e) { Console.WriteLine("sendPacket", e); } catch (IOException e) { Console.WriteLine("sendPacket", e); } }
public void InitAsync() { datagramSocket = new DatagramSocket(DefaultWifiPort); datagramSocket.Broadcast = true; //ReadBuffer 其实这个数据可以缩小,让每次读取的数据量变小 datagramPacket = new DatagramPacket(Readbuffer, Readbuffer.Length); }
public void SendPacket(byte[] wire, IPEndPoint address) { DatagramPacket packet = new DatagramPacket(Unpooled.CopiedBuffer(wire), address); this.channel.WriteAsync(packet); this.channel.Flush(); }
public bool InitAsync(CH34xUARTDriver usbDriver = null, Connections serialDriver = null) { datagramSocket = new DatagramSocket(DefaultWifiPort); datagramSocket.Broadcast = true; datagramPacket = new DatagramPacket(Readbuffer, Readbuffer.Length); return(true); }
public void SendFragmented(string message) { // déduit le nombre de paquets qu'il y aura int packetCount = message.Length / Mtu; // déduit le nombre de charactères restant int lastPacketSize = message.Length % Mtu; // si il reste des charactères restant il faut compter un nouveau paquet qui ne sera pas plein //packetCount += (lastPacketSize != 0) ? 1 : 0; if (packetCount > 1 || (packetCount == 1 && lastPacketSize != 0)) { List <string> buffer = new List <string>(); for (int i = 0; i < packetCount; i++) { int start = i * Mtu; int length = Mtu; buffer.Add(message.Substring(start, length)); } buffer.Add(message.Substring(Mtu * packetCount, message.Length - (Mtu * packetCount))); // ajoute le packet restant si il y a un reste packetCount += (lastPacketSize != 0) ? 1 : 0; for (int i = 0; i < buffer.Count; i++) { DatagramPacket p = new DatagramPacket() { Data = buffer[i], Index = i, IsFragmented = true, PacketCount = packetCount }; string json = JSONSerializer.Serialize <DatagramPacket>(p); byte[] bs = Encoding.ASCII.GetBytes(json); int bc = bs.Length; udpClient.Send(bs, bc, sendEndPoint); Console.WriteLine(json); } } else { DatagramPacket dp = new DatagramPacket() { Index = -1, PacketCount = -1, IsFragmented = false, Data = message }; byte[] bs = Encoding.ASCII.GetBytes(JSONSerializer.Serialize <DatagramPacket>(dp)); int bc = bs.Length; udpClient.Send(bs, bc, SendEndPoint); } Console.WriteLine("{0}; {1}", packetCount, lastPacketSize); }
public OutgoingUDPClientPacket(UDPConnector connector, DatagramPacket data, OutgoingUDPClientPacket previousPacket) { fConnector = connector; fData = data; fPreviousPacket = previousPacket; ThreadPool.QueueUserWorkItem(new WaitCallback(SendData)); }
public IncomingUDPClientPacket(UDPConnector connector, DatagramPacket data, IncomingUDPClientPacket previousPacket) { fConnector = connector; fData = data; fPreviousPacket = previousPacket; connector.fBytesIn += data.Length; ThreadPool.QueueUserWorkItem(new WaitCallback(ReadData)); }
public PacketEvent(DatagramPacket packet) { address = packet.getAddress(); port = packet.getPort(); data = packet.getData(); length = packet.getLength(); // Log.d("PacketEvent"," p:"+packet.getLength()+ " d:"+data.length); }
public CloseMessage_Conn(DatagramPacket dp) { this.dp = dp; dpData = dp.getData(); ver = ByteShortConvert.toShort(dpData, 0); sType = ByteShortConvert.toShort(dpData, 2); connectId = ByteIntConvert.toInt(dpData, 4); clientId = ByteIntConvert.toInt(dpData, 8); }
public PingMessage2(int connectId, int clientId, int pingId) { ByteShortConvert.toByteArray(ver, dpData, 0); //add: ver ByteShortConvert.toByteArray(sType, dpData, 2); //add: service type ByteIntConvert.toByteArray(connectId, dpData, 4); //add: sequence ByteIntConvert.toByteArray(clientId, dpData, 8); //add: sequence ByteIntConvert.toByteArray(pingId, dpData, 12); //add: sequence dp = new DatagramPacket(dpData, dpData.Length); }
public void outPut(IByteBuffer data, Kcp kcp) { Snmp.snmp.OutPkts++; Snmp.snmp.OutBytes += data.WriterIndex; var user = (User)kcp.User; var temp = new DatagramPacket(data, user.LocalAddress, user.RemoteAddress); user.Channel.WriteAndFlushAsync(temp); }
static async Task Main(string[] args) { var group = new MultithreadEventLoopGroup(); var bootstrap = new Bootstrap(); bootstrap .Group(group) .Channel <SocketDatagramChannel>() .Option(ChannelOption.SoBroadcast, true) .Handler(new ActionChannelInitializer <IChannel>(channel => { })); var clientChannel = bootstrap.BindAsync(IPEndPoint.MinPort) .ConfigureAwait(false) .GetAwaiter() .GetResult(); var length = 2000; while (true) { var entity = new LogEntity { Level = LogEventLevel.Information, Machine = "YC", Application = "ConsoleSample", Category = "Test", Message = "proto test", Timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds(), TraceId = "12313", Exception = new string('1', length) }; var data = entity.ToByteArray(); var buffer = Unpooled.WrappedBuffer(data); Console.WriteLine($"Capacity: {buffer.Capacity}, MaxCapacity: {buffer.MaxCapacity}, {buffer.IoBufferCount}"); var packet = new DatagramPacket(buffer, new IPEndPoint(IPAddress.Parse("192.168.2.21"), 6253)); //var packet = new DatagramPacket(buffer, new IPEndPoint(IPAddress.Parse("192.168.2.24"), 32204)); //var packet = new DatagramPacket(buffer, new IPEndPoint(IPAddress.Loopback, 6253)); await clientChannel.WriteAndFlushAsync(packet) .ConfigureAwait(false); await Task.Delay(20); //var cmd = Console.ReadLine(); //if (!int.TryParse(cmd, out length)) //{ // break; //} } await clientChannel.CloseAsync(); await group.ShutdownGracefullyAsync(TimeSpan.FromMilliseconds(100), TimeSpan.FromSeconds(1)); }
public CloseConnPacket(DatagramPacket datagramPacket) { MyDatagramPacket = datagramPacket; DatagramData = datagramPacket.Data; Ver = BitConverter.ToInt16(DatagramData, 0); SType = BitConverter.ToInt16(DatagramData, 2); ConnectId = BitConverter.ToInt32(DatagramData, 4); ClientId = BitConverter.ToInt32(DatagramData, 8); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: @Override public int receive(byte[] buffer, int size) throws java.io.IOException public override int receive(sbyte[] buffer, int size) { DatagramPacket packet = new DatagramPacket(buffer, size); socket.receive(packet); ReceivedPort = packet.Port; ReceivedAddress = packet.Address; return(packet.Length); }
public static async void Process(IChannelHandlerContext ctx, DatagramPacket packet) { var content = packet.Content; var length = content.ReadableBytes; if (length == 1400) { var sessionId = content.ReadLong(); var uselessBytes = content.ReadBytes(2); var sessionBuffer = Unpooled.Buffer(); sessionBuffer.WriteLong(sessionId); sessionBuffer.WriteBytes(uselessBytes); Resources.Sessions.Add(new SessionContext { EndPoint = packet.Sender }, sessionId); await ctx.WriteAsync(new DatagramPacket(sessionBuffer, packet.Sender)); } else { //if (length != 10) //Logger.Log($"Received {length} bytes from {packet.Sender}: {BitConverter.ToString(content.Array.Take(length).ToArray()).Replace("-", "")}", null, ErrorLevel.Debug); var sessionId = content.ReadLong(); var uselessBytes = content.ReadBytes(2); var session = Resources.Sessions.Get(sessionId); if (session == null) { return; } var sessionContext = session.Get(packet.Sender); if (sessionContext != null) { sessionContext.Active = true; if (length != 10) { sessionContext.Process(content, ctx.Channel); } else { var sessionOkBuffer = Unpooled.Buffer(10); sessionOkBuffer.WriteLong(session.Id); sessionOkBuffer.WriteBytes(uselessBytes); await ctx.WriteAsync(new DatagramPacket(sessionOkBuffer, packet.Sender)); } } } }
public void New(EndPoint endPoint, Ukcp ukcp, DatagramPacket msg) { var conv = ukcp.getConv(); if (msg != null) { conv = getConv(msg); ukcp.setConv(conv); } _ukcps.TryAdd(conv, ukcp); }
public CloseConnPacket(int connectId, int clientId) { SType = PacketType.CloseConnPacket; DatagramData = new byte[12]; ClientId = clientId; ConnectId = connectId; BitConverter.GetBytes(Ver).CopyTo(DatagramData, 0); BitConverter.GetBytes(SType).CopyTo(DatagramData, 2); BitConverter.GetBytes(ConnectId).CopyTo(DatagramData, 4); BitConverter.GetBytes(ClientId).CopyTo(DatagramData, 8); MyDatagramPacket = new DatagramPacket(DatagramData, DatagramData.Length); }
/// <summary> /// /// </summary> /// <param name="packet"></param> internal override int send(DatagramPacket packet) { return this.socket_.Send( packet.data, packet.length, this.flags_ ); }
/// <summary> /// /// </summary> /// <param name="packet"></param> internal override void receive(DatagramPacket packet) { this.socket_.Receive( packet.data ); }
/// <summary> /// ���̃\�P�b�g����̃f�[�^�O�����p�P�b�g���M���܂��B /// </summary> /// <param name="packet"></param> internal abstract void receive(DatagramPacket packet);
public void Receive(DatagramPacket var1) { throw new System.NotImplementedException(); }
public void send(DatagramPacket arg0, byte arg1) { Instance.CallMethod("send", "(Ljava/net/DatagramPacket;B)V", arg0, arg1); }
public virtual void OnDataReceive(UDPConnector connector, DatagramPacket packet) { //Console.WriteLine("Data received: " + Encoding.Default.GetString(packet.Bytes)); }
public void Send(DatagramPacket var4) { throw new System.NotImplementedException(); }
/// <summary> /// ���̃\�P�b�g����f�[�^�O�����p�P�b�g�𑗐M���܂��B /// </summary> /// <param name="packet"></param> internal abstract int send(DatagramPacket packet);
/// <summary> /// Send data to host. /// </summary> /// <param name="bytes">The byte array to be send.</param> /// <param name="offset">The position in the data buffer at witch to begin sending.</param> /// <param name="length">The number of the bytes to be send.</param> public void SendData(byte[] bytes, int offset, int length) { DatagramPacket outPacket = new DatagramPacket(bytes, offset, length, fServerEndPoint); fLastOutgoingPacket = new OutgoingUDPClientPacket(this, outPacket, fLastOutgoingPacket); }
private void OnReceive(IAsyncResult ar) { try { IPEndPoint remote = new IPEndPoint(IPAddress.Any, 0); byte[] data = fSocket.EndReceive(ar, ref remote); DatagramPacket packet = new DatagramPacket(data, remote); fLastIncomingPacket = new IncomingUDPClientPacket(this, packet, fLastIncomingPacket); fSocket.BeginReceive(OnReceive, null); } catch (Exception ex) { } }