Exemplo n.º 1
0
 void SendRCONPacket(RCONPacket p)
 {
     byte[] Packet = p.OutputAsBytes();
     if (S.Connected)
     {
         S.BeginSend(Packet, 0, Packet.Length, SocketFlags.None, new AsyncCallback(SendCallback), this);
     }
 }
Exemplo n.º 2
0
        public bool Connect(IPEndPoint Server, string password)
        {
            try
            {
                IAsyncResult ar = null;
                try
                {
                    ar = S.BeginConnect(Server, null, null);
                }
                catch (ObjectDisposedException)
                {
                    S           = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                    PacketCount = 0;

#if DEBUG
                    TempPackets = new ArrayList();
#endif

                    return(false);
                }
                ar.AsyncWaitHandle.WaitOne(2000);                 // wait 2 seconds
                if (!ar.IsCompleted)
                {
                    OnError(ConnectionTimeout);
                    S.Close();
                    return(false);
                }
                else                 // WAIT IS COMPLETED - if not connectsuccess (triggered elsewhere from sending auth packet), don't do forced timeout close
                {
                    RCONPacket SA = new RCONPacket();
                    SA.RequestId      = 1;
                    SA.String1        = password;
                    SA.ServerDataSent = RCONPacket.SERVERDATA_sent.SERVERDATA_AUTH;

                    SendRCONPacket(SA);                  // auth packet

                    if (S.Connected)                     //
                    {
                        StartGetNewPacket();
                        // This is the first time we've sent, so we can start listening now!
                        return(true);
                    }
                    else
                    {
                        OnError(UnknownConnectionIssue);                         // idk what exactly
                        S.Close();
                        return(false);
                    }
                }
                //S.Connect(Server);
            }
            catch (SocketException)
            {
                OnError(ConnectionFailedString);
                OnConnectionSuccess(false);
                return(false);
            }
        }
Exemplo n.º 3
0
 public void ServerCommand(string command)
 {
     if (connected)
     {
         RCONPacket PacketToSend = new RCONPacket();
         PacketToSend.RequestId      = 2;
         PacketToSend.ServerDataSent = RCONPacket.SERVERDATA_sent.SERVERDATA_EXECCOMMAND;
         PacketToSend.String1        = command;
         SendRCONPacket(PacketToSend, command);
         //OnCommandOutput(command);
     }
 }
Exemplo n.º 4
0
        void ProcessIncomingData(RecState state)
        {
            if (state.IsPacketLength)
            {
                // First 4 bytes of a new packet.
                state.PacketLength = BitConverter.ToInt32(state.Data, 0);

                state.IsPacketLength = false;
                state.BytesSoFar     = 0;
                state.Data           = new byte[state.PacketLength];
                S.BeginReceive(state.Data, 0, state.PacketLength, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);
            }
            else
            {
                // Do something with data...

                if (state.BytesSoFar < state.PacketLength)
                {
                    // Missing data.
                    S.BeginReceive(state.Data, state.BytesSoFar, state.PacketLength - state.BytesSoFar, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);
                }
                else
                {
                    // Process data.
#if DEBUG
                    Console.WriteLine("Complete packet.");
#endif

                    RCONPacket RetPack = new RCONPacket();
                    if (state.Data.Length != 0)
                    {
                        RetPack.ParseFromBytes(state.Data, this);
                        ProcessResponse(RetPack);
                        // Wait for new packet.
                        if (S.Connected)
                        {
                            StartGetNewPacket();
                        }
                    }
                    else
                    {
                        //Console.WriteLine("KICKED TIMEOUT DATA:" + UTF8Encoding.UTF8.GetString(state.Data));
                        OnError(ConnectionClosed);
                        S.Close();
                    }
                    return;
                }
            }
        }
Exemplo n.º 5
0
        void ProcessResponse(RCONPacket P)
        {
            switch (P.ServerDataReceived)
            {
            case RCONPacket.SERVERDATA_rec.SERVERDATA_AUTH_RESPONSE:
                if (P.RequestId != -1)
                {
                    // Connected.
                    connected = true;
                    OnSuccessOutput(ConnectionSuccessString);
                    OnConnectionSuccess(true);
                }
                else
                {
                    // Failed!
                    OnError(WrongPassword);
                    OnConnectionSuccess(false);
                    S.Close();
                }
                break;

            case RCONPacket.SERVERDATA_rec.SERVERDATA_RESPONSE_VALUE:
                if (hadjunkpacket)
                {
                    // Real packet!
                    OnServerOutput(P.String1);
                }
                else
                {
                    hadjunkpacket = true;
                    //OnError(GotJunkPacket);
                }
                break;

            default:
                OnError(UnknownResponseType);
                break;
            }
        }