Beispiel #1
0
        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());
        }
    }
Beispiel #5
0
        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);
        }
Beispiel #6
0
    //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);
        }
Beispiel #9
0
 // 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);
     }
 }
Beispiel #10
0
            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();
                    }
                }
            }
Beispiel #11
0
        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();
        }
Beispiel #12
0
//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);
                }
            }
Beispiel #13
0
        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);
            }
        }
Beispiel #14
0
 /// <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;
     }
 }
Beispiel #15
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);
            }
        }
Beispiel #16
0
 public void InitAsync()
 {
     datagramSocket           = new DatagramSocket(DefaultWifiPort);
     datagramSocket.Broadcast = true;
     //ReadBuffer  其实这个数据可以缩小,让每次读取的数据量变小
     datagramPacket = new DatagramPacket(Readbuffer, Readbuffer.Length);
 }
Beispiel #17
0
        public void SendPacket(byte[] wire, IPEndPoint address)
        {
            DatagramPacket packet = new DatagramPacket(Unpooled.CopiedBuffer(wire), address);

            this.channel.WriteAsync(packet);
            this.channel.Flush();
        }
Beispiel #18
0
 public bool InitAsync(CH34xUARTDriver usbDriver = null, Connections serialDriver = null)
 {
     datagramSocket           = new DatagramSocket(DefaultWifiPort);
     datagramSocket.Broadcast = true;
     datagramPacket           = new DatagramPacket(Readbuffer, Readbuffer.Length);
     return(true);
 }
Beispiel #19
0
        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));
 }
Beispiel #22
0
        public OutgoingUDPClientPacket(UDPConnector connector, DatagramPacket data, OutgoingUDPClientPacket previousPacket)
        {
            fConnector      = connector;
            fData           = data;
            fPreviousPacket = previousPacket;

            ThreadPool.QueueUserWorkItem(new WaitCallback(SendData));
        }
Beispiel #23
0
 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 IncomingUDPClientPacket(UDPConnector connector, DatagramPacket data, IncomingUDPClientPacket previousPacket)
 {
     fConnector          = connector;
     fData               = data;
     fPreviousPacket     = previousPacket;
     connector.fBytesIn += data.Length;
     ThreadPool.QueueUserWorkItem(new WaitCallback(ReadData));
 }
 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);
 }
Beispiel #27
0
        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);
        }
Beispiel #28
0
        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));
        }
Beispiel #29
0
        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);
        }
Beispiel #30
0
//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 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);
        }
        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);
        }
Beispiel #35
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="packet"></param>
 internal override int send(DatagramPacket packet)
 {
     return this.socket_.Send( packet.data, packet.length, this.flags_ );
 }
Beispiel #36
0
 /// <summary>
 /// 
 /// </summary>
 /// <param name="packet"></param>
 internal override void receive(DatagramPacket packet)
 {
     this.socket_.Receive( packet.data );
 }
Beispiel #37
0
 /// <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);
 }
Beispiel #40
0
 public virtual void OnDataReceive(UDPConnector connector, DatagramPacket packet)
 {
     //Console.WriteLine("Data received: " + Encoding.Default.GetString(packet.Bytes));
 }
Beispiel #41
0
 public void Send(DatagramPacket var4)
 {
     throw new System.NotImplementedException();
 }
Beispiel #42
0
 /// <summary>
 /// ���̃\�P�b�g����f�[�^�O�����p�P�b�g�𑗐M���܂��B
 /// </summary>
 /// <param name="packet"></param>
 internal abstract int send(DatagramPacket packet);
Beispiel #43
0
 /// <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);
 }
Beispiel #44
0
        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)
            {

            }
        }