示例#1
0
文件: Client.cs 项目: Quget/Q-Server
        private void StartReceive()
        {
            new Thread(delegate()
            {
                byte[] buffer = new byte[DATA_LENGTH];
                while (true)
                {
                    try
                    {
                        if (isClosed || !socket.Connected)
                        {
                            //Close();
                            return;
                        }
                        buffer     = new byte[socket.Available];
                        int length = socket.Receive(buffer, buffer.Length, SocketFlags.None);

                        if (length <= 0)
                        {
                            continue;
                        }
                        string packetString = Encoding.Default.GetString(buffer);
                        OnReceive(packetString);
                        //Thread.Sleep(1);
                    }
                    catch (Exception e)
                    {
                        Eutils.FileError(String.Format("{0} {1} \n", e.Message, e.StackTrace), "client_error.txt");
                        Eutils.WriteLine("Error Receiving! Message:{0} Stacktrace: {1}", Eutils.MESSSAGE_TYPE.ERROR, e.Message, e.StackTrace);
                        Close();
                        break;
                    }
                }
            }).Start();
        }
示例#2
0
文件: Client.cs 项目: Quget/Q-Server
 private void ReceiveCallback(IAsyncResult ar)
 {
     try
     {
         StateObject state = (StateObject)ar.AsyncState;
         if (isClosed || socket == null || !socket.Connected || socket.Available != 0 || socket.Poll(0, SelectMode.SelectRead))
         {
             Close();
             return;
         }
         // Read data from the client socket.
         int bytesRead = socket.EndReceive(ar);
         //More data
         if (bytesRead > 0)
         {
             state.stringBuilder.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
             string packetData = state.stringBuilder.ToString();
             state = new StateObject();//reset
             socket.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
             OnReceive(packetData);
         }
     }
     catch (Exception e)
     {
         Eutils.FileError(String.Format("{0} {1} \n", e.Message, e.StackTrace), "client_error.txt");
         Eutils.WriteLine("Error receiving:{0} {1}", Eutils.MESSSAGE_TYPE.ERROR, e.Message, e.StackTrace);
         Close();
     }
 }
示例#3
0
文件: Client.cs 项目: Quget/Q-Server
        public void Send(string dataToSend)
        {
            if (isClosed)
            {
                return;
            }
            if (socket == null || !socket.Connected)
            {
                Close();
                return;
            }

            dataToSend = QEncryption.Encrypt(dataToSend);
            dataToSend = PacketDatas.PACKET_HEADER + dataToSend;
            //We us UTF8 characterss so lets convert the bytes into utf8 string!
            byte[] dataBytes = Encoding.UTF8.GetBytes(dataToSend);
            //And then send it to our client.
            try
            {
                socket.Send(dataBytes, SocketFlags.None);
            }
            catch (Exception e)
            {
                Eutils.FileError(String.Format("{0} {1} \n", e.Message, e.StackTrace), "client_error.txt");
                Eutils.WriteLine("Error Sending! Message:{0}", Eutils.MESSSAGE_TYPE.ERROR, e.Message, e.StackTrace);
                Close();
            }
        }
示例#4
0
文件: Client.cs 项目: Quget/Q-Server
 private void OnReceive(string packetString)
 {
     //Then we send this.
     if (packetString[0].ToString() != PacketDatas.PACKET_HEADER)
     {
         Close();
         return;
     }
     string[] packets = packetString.Split(new string[] { PacketDatas.PACKET_HEADER }, StringSplitOptions.None);
     for (int i = 1; i < packets.Length; i++)
     {
         //Eutils.WriteLine("received data:{0} at Time:{1} Length:{2}", Eutils.MESSSAGE_TYPE.NORMAL, packets[i], DateTime.Now, packets[i].Length);
         packets[i] = QEncryption.Decrypt(packets[i]);
         Eutils.WriteLine("decrypted data:{0} at Time:{1} Length:{2}", Eutils.MESSSAGE_TYPE.NORMAL, packets[i], DateTime.Now, packets[i].Length);
         if (packets[i] == "NULL")
         {
             Eutils.FileError(String.Format("{0} \n", "Error decrypting: packets[i] == NULL"), "client_error.txt");
             Eutils.WriteLine("Error decrypting", Eutils.MESSSAGE_TYPE.ERROR);
             //Close();
             break;
         }
         //Split the packet by our split character.
         string[] packetStrings = packets[i].Split(new string[] { PacketDatas.PACKET_SPLIT }, StringSplitOptions.None);
         received(this, packetStrings);
     }
 }
示例#5
0
        protected override void client_received(Client sender, string[] packetStrings)
        {
            switch (packetStrings[0])
            {
            case PacketDatas.PACKET_CHAT:
                DoChat(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GAME_CREATE:
                CreateGameRoom(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GAME_SEL:
                SelectGameRoom(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GET_GAME_ROOM:
                GameRoomsUpdate(sender, packetStrings);
                break;

            default:
                Eutils.WriteLine("Lobby Error wrong packet! {0}", Eutils.MESSSAGE_TYPE.WARNING, packetStrings[1]);
                break;
            }
        }
示例#6
0
        protected override void client_received(Client sender, string[] packetStrings)
        {
            switch (packetStrings[0])
            {
            case PacketDatas.PACKET_CHAT:
                DoChat(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GAME_STOP:
                GameStop(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GAME_POS:
                DoSendPos(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GAME_IMAGE_START:
                DoSendImageStart(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GAME_IMAGE:
                DoSendImage(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GAME_IMAGE_END:
                DoSendImageEnd(sender, packetStrings);
                break;

            default:
                Eutils.WriteLine("[Gameroom InGame {1}] Error wrong packet! {0}", Eutils.MESSSAGE_TYPE.ERROR, packetStrings[1], gameRoom.gameRoomName);
                break;
            }
        }
示例#7
0
 public GameRoom(Client owner, Lobby lLobby, string name = "null") : base()
 {
     lobby         = lLobby;
     gameroomOwner = owner;
     gameRoomName  = name;
     Eutils.WriteLine("Created Gameroom {0}", Eutils.MESSSAGE_TYPE.NORMAL, name);
 }
示例#8
0
文件: Login.cs 项目: Quget/Q-Server
        //The login function.
        private void DoLogin(Client sender, String[] packetStrings)
        {
            bool userCorrect = true; //Correct
            bool passCorrect = true; //correct

            //Everything needs to be right. If something is wrong then goodbye.
            if (!userCorrect || !passCorrect || packetStrings[1].Length < 1 || packetStrings[2].Length < 1)
            {
                //<3 the first packed you see!
                //We send a error packet.
                sender.Send(PacketDatas.PACKET_ERROR + PacketDatas.PACKET_SPLIT + "Invalid username or password");

                Eutils.WriteLine("Login in failed by ip: {0}", Eutils.MESSSAGE_TYPE.WARNING, sender.ipEndpoint.Address);
                sender.Close();//DC
                return;
            }
            //Set the username
            sender.userName   = packetStrings[1];
            sender.isLoggedIn = true;
            //Login succes! We just send a login packet back
            sender.Send(PacketDatas.PACKET_LOGIN);
            Eutils.WriteLine("Login in:{0} with password:{1} ip: {2}", Eutils.MESSSAGE_TYPE.NORMAL, packetStrings[1], packetStrings[2], sender.ipEndpoint.Address);
            //We remove the receive event to so the lobby can handle the receiving now.
            RemoveClient(sender);
            //Add client to the lobby.
            lobby.AddClient(sender);
        }
示例#9
0
 protected override void visitor_disconnected(Client sender)
 {
     disCount++;
     base.visitor_disconnected(sender);
     Eutils.WriteLine("Client Disconnected: {0}", Eutils.MESSSAGE_TYPE.NORMAL, sender.ID);
     UpdateStats();
     Sweep();
 }
示例#10
0
 //The big received function.
 protected override void client_received(Client sender, string[] packetStrings)
 {
     //So what kind of packet is it?
     switch (packetStrings[0])
     {
     default:
         Eutils.WriteLine("main server Error wrong packet! {0}", Eutils.MESSSAGE_TYPE.WARNING);
         break;
     }
 }
示例#11
0
文件: Login.cs 项目: Quget/Q-Server
        protected override void client_received(Client sender, string[] packetStrings)
        {
            //So what kind of packet is it?
            switch (packetStrings[0])
            {
            case PacketDatas.PACKET_LOGIN:      //Login packet! we log in.
                DoLogin(sender, packetStrings); //Do this function.
                break;

            default:
                Eutils.WriteLine("Login Error wrong packet! {0}", Eutils.MESSSAGE_TYPE.WARNING, packetStrings[1]);
                break;
            }
        }
示例#12
0
        protected override void client_received(Client sender, string[] packetStrings)
        {
            switch (packetStrings[0])
            {
            case PacketDatas.PACKET_CHAT:
                DoChat(sender, packetStrings);
                break;

            case PacketDatas.PACKET_GAME_START:
                DoStartGame(sender, packetStrings);
                break;

            default:
                Eutils.WriteLine("[Gameroom {1}] Error wrong packet! {0}", Eutils.MESSSAGE_TYPE.WARNING, packetStrings[1], gameRoomName);
                break;
            }
        }
示例#13
0
        //A client got connected! Aka socket accepted!
        private void listener_SocketAccepted(Socket e)
        {
            Client client = new Client(e);                                                     //it is a client.

            Eutils.WriteLine("Client Connected: {0}", Eutils.MESSSAGE_TYPE.NORMAL, client.ID); //Client.ID is random, every client is unique
            AddClient(client);
            if (clients.Count <= maxCount)
            {
                login.AddClient(client);
                client.received -= new Client.ClientReceivedHandler(client_received);
                UpdateStats();
            }
            else
            {
                client.Close();
            }
        }
示例#14
0
        public void Start()
        {
            //Are we already listening?
            if (bListening)
            {
                return;//then we shouldn't listen again
            }
            //Lets bind! we are going to bind on a port!
            sSocket.Bind(new IPEndPoint(0, nPort));
            //Now we are going to listen.
            sSocket.Listen(0);
            //asynchronous accepting clients.
            //  StartListening();
            sSocket.BeginAccept(beginAcceptCallback, null);
            bListening = true;//We are ready and listening.

            Eutils.WriteLine("Server is Listening on port {0}", Eutils.MESSSAGE_TYPE.NORMAL, nPort);
        }
示例#15
0
 private void Sweep()
 {
     for (int i = 0; i < clients.Count; i++)
     {
         if (clients[i] == null)
         {
             clients.RemoveAt(i);
             i--;
         }
         else if (clients[i].isClosed)
         {
             clients.RemoveAt(i);
             i--;
         }
     }
     Eutils.WriteLine("Clients Sweeped", Eutils.MESSSAGE_TYPE.NORMAL);
     UpdateStats();
 }
示例#16
0
 //when a client got accepted this happends.
 void beginAcceptCallback(IAsyncResult ar)
 {
     try
     {
         Socket s = sSocket.EndAccept(ar); //Lets get the clients socket!
         if (socketAccepted != null)       //if no one is listening then we can't send it.
         {
             //Lets send this event with the clients socket
             socketAccepted(s);
         }
         //And we start over again.
         //A loop!
         sSocket.BeginAccept(beginAcceptCallback, null);
     }
     catch (Exception e)
     {
         Eutils.WriteLine("Error accepting! Message:{0}", Eutils.MESSSAGE_TYPE.ERROR, e.Message, e.StackTrace);
     }
 }
示例#17
0
 private void StartListening()
 {
     new Thread(delegate()
     {
         while (true)
         {
             try
             {
                 Socket socket  = sSocket.Accept();
                 socket.NoDelay = true;
                 socketAccepted(socket);
             }
             catch (Exception e)
             {
                 Eutils.WriteLine("Error Accepting! Message:{0}", Eutils.MESSSAGE_TYPE.ERROR, e.Message, e.StackTrace);
                 continue;
             }
         }
     }).Start();
 }