public Client(String host, Int32 port)
        {
            try
            {

                clientName = Dns.GetHostName();

            }
            catch (SocketException se)
            {

                MessageBox.Show("ERROR: Could not retrieve client's DNS hostname.  Please try again." + se.Message + ".", "Client Socket Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;

            }

            serverName = host;
            gamePort = port;
            client = new TcpClient(host, port);
            netStream = client.GetStream();
            reader = new StreamReader(netStream);
            writer = new StreamWriter(netStream);
            ssl = new SslStream(netStream, false, new RemoteCertificateValidationCallback(ValidateCert));
            cert = new X509Certificate2("server.crt");
            ssl.AuthenticateAsClient(serverName);
            writer.AutoFlush = true;
        }
Example #2
1
        static void Main(string[] args)
        {
            var m_Config = new ServerConfig
            {
                Port = 911,
                Ip = "Any",
                MaxConnectionNumber = 1000,
                Mode = SocketMode.Tcp,
                Name = "CustomProtocolServer"
            };

            var m_Server = new CustomProtocolServer();
            m_Server.Setup(m_Config, logFactory: new ConsoleLogFactory());
            m_Server.Start();

            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);

            using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
            {
                socket.Connect(serverAddress);

                var socketStream = new NetworkStream(socket);
                var reader = new StreamReader(socketStream, Encoding.ASCII, false);

                string charSource = Guid.NewGuid().ToString().Replace("-", string.Empty)
                    + Guid.NewGuid().ToString().Replace("-", string.Empty)
                    + Guid.NewGuid().ToString().Replace("-", string.Empty);

                Random rd = new Random();

                var watch = Stopwatch.StartNew();
                for (int i = 0; i < 10; i++)
                {
                    int startPos = rd.Next(0, charSource.Length - 2);
                    int endPos = rd.Next(startPos + 1, charSource.Length - 1);

                    var currentMessage = charSource.Substring(startPos, endPos - startPos + 1);

                    byte[] requestNameData = Encoding.ASCII.GetBytes("ECHO");
                    socketStream.Write(requestNameData, 0, requestNameData.Length);
                    var data = Encoding.ASCII.GetBytes(currentMessage);
                    socketStream.Write(new byte[] { (byte)(data.Length / 256), (byte)(data.Length % 256) }, 0, 2);
                    socketStream.Write(data, 0, data.Length);
                    socketStream.Flush();

                   // Console.WriteLine("Sent: " + currentMessage);

                    var line = reader.ReadLine();
                    //Console.WriteLine("Received: " + line);
                    //Assert.AreEqual(currentMessage, line);
                }

                

                watch.Stop();
                Console.WriteLine(watch.ElapsedMilliseconds);
            }

            Console.ReadLine();
        }
        void ConnectCompleted( object sender, SocketAsyncEventArgs e )
        {
            sock = sender as Socket;

            if ( sock == null )
            {
                OnDisconnected( EventArgs.Empty );
                return;
            }

            if ( e.SocketError != SocketError.Success )
            {
                DebugLog.WriteLine( "TcpConnection", "Unable to connect: {0}", e.SocketError );
                OnDisconnected( EventArgs.Empty );
                return;
            }

            DebugLog.WriteLine( "TcpConnection", "Connected!" );

            isConnected = true;

            netStream = new NetworkStream( sock, false );

            netReader = new BinaryReader( netStream );
            netWriter = new BinaryWriter( netStream );

            // initialize our network thread
            netThread = new Thread( NetLoop );
            netThread.Name = "TcpConnection Thread";
            netThread.Start();

            OnConnected( EventArgs.Empty );
        }
Example #4
0
        private void bnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                client = new TcpClient(txtConnect.Text, 2000);
                ns = client.GetStream();
                sr = new StreamReader(ns);
                sw = new StreamWriter(ns);
                dato = sr.ReadLine()
                    + System.Environment.NewLine
                    + sr.ReadLine()
                    + System.Environment.NewLine
                    + sr.ReadLine();

                DelegadoRespuesta dr = new DelegadoRespuesta(EscribirFormulario);
                Invoke(dr);

            }
            catch (Exception err)
            {
                Console.WriteLine(err.ToString());
                throw;
            }


        }
Example #5
0
		public void NetworkStreamConnection ()
		{
			IPEndPoint ipe = new IPEndPoint(Dns.GetHostEntry ("www.google.com").AddressList [0], 80);
			Socket s = new Socket(ipe.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
			s.Close ();
			NetworkStream ns = new NetworkStream (s);
		}
Example #6
0
        void ConnectCompleted( Socket sock )
        {
            if ( sock == null )
            {
                OnDisconnected( EventArgs.Empty );
                return;
            }

            if ( !sock.Connected )
            {
                DebugLog.WriteLine( "TcpConnection", "Unable to connect" );
                OnDisconnected( EventArgs.Empty );
                return;
            }

            DebugLog.WriteLine( "TcpConnection", "Connected!" );

            isConnected = true;

            netStream = new NetworkStream( sock, false );

            netReader = new BinaryReader( netStream );
            netWriter = new BinaryWriter( netStream );

            // initialize our network thread
            netThread = new Thread( NetLoop );
            netThread.Name = "TcpConnection Thread";
            netThread.Start();

            OnConnected( EventArgs.Empty );
        }
        void LayDL()
        {
            try
            {
                cl = new Server_Client.Client();
                // gán TCPclient
                this.client1 = cl.Connect(Luu.IP, Luu.Ports);
                //truyền giá trị lên server
                clientstrem = cl.SerializeObj(this.client1, "LayBackUp", null);
                // đổ mảng đối tượng vào datagripview
                slht = (Entities.SaoLuuHeThong[])cl.DeserializeHepper1(clientstrem, null);
                if (slht != null)
                {
                    if (slht.Length > 0)
                    {
                        dgvHienThi.DataSource = slht;
                    }
                }
                else
                {
                    slht = new Entities.SaoLuuHeThong[0];
                    dgvHienThi.DataSource = slht;
                }
                fix();
            }
            catch
            {
                dgvHienThi.DataSource = new Entities.SaoLuuHeThong[0];
                fix();
            }

            dgvHienThi.Refresh();
        }
Example #8
0
        void SendCommand(NetworkStream stream, byte command, byte[] host, int port)
        {
            byte[] request = new byte[9];
            request[0] = Version;
            request[1] = command;
            request[2] = (byte)(port / 256);
            request[3] = (byte)(port % 256);
            host.CopyTo(request, 4);
            request[8] = 0;
            stream.Write(request, 0, request.Length);

            byte[] response = new byte[8];
            stream.Read(response, 0, response.Length);
            // check null byte
            if (response[0] != 0)
                throw new Socks4Exception("Server response: invalid null byte");
            switch (response[1])
            {
                case Reply.RequestGranted:
                    return;
                case Reply.RequestRejectedOrFailed:
                    throw new Socks4Exception("Server response: request rejected or failed");
                case Reply.ClientNotIdent:
                    throw new Socks4Exception("Server response: request failed because client is not running identd (or not reachable from the server)");
                case Reply.ClientIdentUserIDFailed:
                    throw new Socks4Exception("request failed because client's identd could not confirm the user ID string in the request");
                default:
                    throw new Socks4Exception("Server response: unknown reply");
            }
        }
Example #9
0
        public Game(NetworkStream ns, string op_name)
        {
            InitializeComponent();
            GridX = new int[15];
            GridY = new int[10];
            Network_Stream = ns;
            arr = new char[19, 29];
            lines = new int[29];

            player1 = new Player();
            client = new Client();
            player1.OpponentName = op_name;
            if (Player.IsServer)
            {
                turn = Player.Name;
                waiting = player1.OpponentName;
            }
            else
            {
                turn = player1.OpponentName;
                waiting = Player.Name;
            }

            Thread read = new Thread(() => Read_Stream());
            read.IsBackground = true;
            read.Start();
        }
Example #10
0
        public void checkConflict()
        {
            Server_Client.Client client= new Server_Client.Client();
             this.tcpClient = client.Connect(Luu.IP, Luu.Ports);

             Entities.KhoHang kh = new Entities.KhoHang("Select");
             Entities.KhoHang[] kh1 = new Entities.KhoHang[1];
             networkStream = client.SerializeObj(this.tcpClient, "KhoHang", kh);

             kh1 = (Entities.KhoHang[])client.DeserializeHepper1(networkStream, kh1);
             if (kh1 != null)
             {
                 for (int j = 0; j < kh1.Length; j++)
                 {
                     if (kh1[j].MaKho == txtMaKho.Text)
                     {
                         MessageBox.Show("Thất bại");
                         chck = "No";
                         txtMaKho.Text = new Common.Utilities().ProcessID(txtMaKho.Text);
                         break;
                     }
                     else
                         chck = "Yes";
                 }
             }
        }
Example #11
0
 public void HandleRequest(Url url, NetworkStream stream)
 {
     foreach (IPlugin p in plugins)
     {
         p.handleRequest(url, stream);
     }
 }
Example #12
0
File: rtest.cs Project: nobled/mono
	static void Main (string [] args)
	{
		int i = 0;

		while (args [i].StartsWith ("-")){
			if (args [i] == "-debug")
				debug = true;
			if (args [i] == "-headers")
				headers = true;
			if (args [i] == "-header")
				header = args [++i];
			i++;
		}
		
		c = new TcpClient (args [i], Int32.Parse (args [i+1]));
		c.ReceiveTimeout = 1000;
		ns = c.GetStream ();
		
		sw = new StreamWriter (ns);
		sr = new StreamReader (ns);

		string host = args [i];
		if (args [i+1] != "80")
			host += ":" + args [i+1];
		send (String.Format ("GET {0} HTTP/1.1\r\nHost: {1}\r\n\r\n", args [i+2], host));

		MemoryStream ms = new MemoryStream ();
		
		try {
			byte [] buf = new byte [1024];
			int n;
			
			while ((n = ns.Read (buf, 0, 1024)) != 0){
				ms.Write (buf, 0, n);
			}
		} catch {}

		ms.Position = 0;
		sr = new StreamReader (ms);

		string s;
		
		while ((s = sr.ReadLine ()) != null){
			if (s == ""){
				if (headers)
					return;
				
				string x = sr.ReadToEnd ();
				Console.Write (x);
				break;
			}  else {
				if (debug || headers)
					Console.WriteLine (s);
				if (header != null && s.StartsWith (header)){
					Console.WriteLine (s);
					return;
				}
			}
		}
	}
Example #13
0
        private void Release( bool userRequestedDisconnect )
        {
            lock (netLock)
            {
                cancellationToken.Dispose();
                cancellationToken = null;

                if (netWriter != null)
                {
                    netWriter.Dispose();
                    netWriter = null;
                }

                if (netReader != null)
                {
                    netReader.Dispose();
                    netReader = null;
                }

                if (netStream != null)
                {
                    netStream.Dispose();
                    netStream = null;
                }

                socket.Close();
                socket = null;

                netFilter = null;
            }

            OnDisconnected( new DisconnectedEventArgs( userRequestedDisconnect ) );

            connectionFree.Set();
        }
Example #14
0
        public bool Connect()
        {
            string IP = "127.0.0.1";
            client = new TcpClient(IP, 345);
            if (client.Client.Connected)
            {
                ns = client.GetStream();
                sr = new StreamReader(ns);
                sw = new StreamWriter(ns);
                string challengeCode = sr.ReadLine();
                challengeCode = challengeCode.Substring(challengeCode.IndexOf(' ') + 1);
                string responseCode = "";
                for (int i = challengeCode.Length - 1; i >= 0; i--)
                {
                    responseCode += challengeCode[i];
                }
                sw.AutoFlush = true;
                sw.WriteLine(responseCode);
                if (sr.ReadLine() == "Challenge code accepted")
                {

                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
Example #15
0
		internal HttpClient(Socket socket, HttpServer server)
		{
			this.server = server;
			this.socket = socket;
			IPEndPoint remoteEndPoint = (IPEndPoint)socket.RemoteEndPoint;
			isConnected = true;
			this.remoteAddress = remoteEndPoint.Address.ToString();
			this.remotePort = remoteEndPoint.Port;

			server.Stopping += new EventHandler(server_Stopping);

			stream = new NetworkStream(socket, true);

			try
			{
				stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(OnReceiveData), this);
				
			}
			catch(IOException)
			{
				Disconnect();
				throw;
			}
			server.OneHertzTick += new EventHandler(server_OneHertzTick);
		}
Example #16
0
        static void BackupProcess()
        {
            Console.WriteLine("I am backup!");
            
            IPAddress ipAddress = Dns.GetHostEntry("localhost").AddressList[0];
            TcpListener listener = new TcpListener(ipAddress, port);
            listener.Start();
            Socket sock = listener.AcceptSocket();
            Stream str = new NetworkStream(sock);
            StreamReader sr = new StreamReader(str);

            string line = "-1";

            try
            {
                while (true)
                    line = sr.ReadLine();
            }
            catch(IOException)
            { 
                sr.Close();
                listener.Stop();

                PrimaryProcess(Convert.ToInt32(line) + 1);
            }
        }
Example #17
0
        private static ConnectionDetails GetConnectionDetails(NetworkStream networkStream, TcpClient tcpClient)
        {
            // read the header and check that it is a GET request
            string header = HttpHelper.ReadHttpHeader(networkStream);
            Regex getRegex = new Regex(@"^GET(.*)HTTP\/1\.1");

            Match getRegexMatch = getRegex.Match(header);
            if (getRegexMatch.Success)
            {
                // extract the path attribute from the first line of the header
                string path = getRegexMatch.Groups[1].Value.Trim();

                // check if this is a web socket upgrade request
                Regex webSocketUpgradeRegex = new Regex("Upgrade: websocket");
                Match webSocketUpgradeRegexMatch = webSocketUpgradeRegex.Match(header);

                if (webSocketUpgradeRegexMatch.Success)
                {
                    return new ConnectionDetails(networkStream, tcpClient, path, ConnectionType.WebSocket, header);
                }
                else
                {
                    return new ConnectionDetails(networkStream, tcpClient, path, ConnectionType.Http, header);
                }
            }
            else
            {
                return new ConnectionDetails(networkStream, tcpClient, string.Empty, ConnectionType.Unknown, header); 
            }
        }
Example #18
0
        public void runServer()
        {
            StreamReader fileListReader;

            Console.WriteLine("Alexandria-Server 0.02a \n Written by: \n j0z");
            Console.WriteLine("Starting server...");
            tcpListener.Start();
            Console.WriteLine("Loading filelist...");

            if (File.Exists("fileList.txt"))
            {
                fileList.loadFileList();
                Console.WriteLine("Loaded filelist!");
            }
            else
            {
                Console.WriteLine("Filelist not found, creating...");
                fileList.createFileList();
                Console.WriteLine("Filenames: \n" + fileList.name[0]);
                Console.WriteLine("File sizes: \n" + fileList.size[0]);
                Console.WriteLine("Created filelist!");
            }

            Console.WriteLine("Server Started!");

            bool fileComplete = false;

            while (true)
            {
                TcpClient tcpClient = tcpListener.AcceptTcpClient();
                Console.WriteLine("Client Connected!");
                stream = tcpClient.GetStream();
                byte[] incomingData = new byte[tcpClient.ReceiveBufferSize];
                int bytesRead = stream.Read(incomingData, 0, System.Convert.ToInt32(tcpClient.ReceiveBufferSize));

                string command = Encoding.ASCII.GetString(incomingData, 0, bytesRead);

                Console.WriteLine("Received command: " + command);

                string[] commands = command.Split(seperators);

                foreach (string x in commands)
                {
                    Console.WriteLine(x);
                }

                switch (commands[0])
                {
                    case "get":
                        get(commands[1], commands[2]);
                        break;
                    case "put":
                        put(commands[1], commands[2]);
                        break;
                    default:
                        Console.WriteLine("Invalid command received");
                        break;
                }
            }
        }
Example #19
0
        public void TestWorkerIncompleteData()
        {
            StringBuilder output = new StringBuilder();
            Process worker;
            TcpListener CSharpRDD_SocketServer = CreateServer(output, out worker);

            using (var serverSocket = CSharpRDD_SocketServer.AcceptSocket())
            using (var s = new NetworkStream(serverSocket))
            {
                WriteWorker(s);

                SerDe.Write(s, command.Length);
                s.Write(command, 0, command.Length);

                for (int i = 0; i < 100; i++)
                    SerDe.Write(s, i.ToString());

                int count = 0;
                foreach (var bytes in ReadWorker(s, 100))
                {
                    Assert.AreEqual(count++.ToString(), Encoding.UTF8.GetString(bytes));
                }

                Assert.AreEqual(100, count);
            }

            AssertWorker(worker, output, -1, "System.NullReferenceException: Object reference not set to an instance of an object.");

            CSharpRDD_SocketServer.Stop();
        }
Example #20
0
        public static void SendXContent(NetworkStream nstm, byte[] content, int offset, int length)
        {
            byte[] balen = IntHexBytes(length); // Don't use LongLength here because nstm.Write only uses int anyway.
            nstm.Write(balen, 0, balen.Length);

            nstm.Write(content, offset, length);
        }
Example #21
0
 // constructeur
 public FormServeur()
 {
     InitializeComponent();
     Joueur1 = new Joueur(panelFond, new Point(100, 100),true);
     Joueur2 = new Joueur(panelFond, new Point(100, 150),false); // Cette fois les joueurs sont clairements
     labelScoreJ1.Text = "0";
     labelScoreJ2.Text = "0"; // L'interface n'est plus la même non plus, on dédouble tout.
     pBChargeJ1.Maximum = 1000;
     pBChargeJ1.Minimum = 0;
     pBChargeJ2.Maximum = 1000;
     pBChargeJ2.Minimum = 0;
     try
     {
         IPAddress ipAd = IPAddress.Parse("127.0.0.1"); //on utilise l'adresse ip locale
         myList = new TcpListener(ipAd, 8001);   //initialisation du listener
         myList.Start();                         // on écoute sur le port
         Console.WriteLine("The server is running at port 8001...");
         Console.WriteLine("The local End point is :" + myList.LocalEndpoint); // Ces trois lignes ci ne servent qu'a controler via la console ce qui se passe.
         Console.WriteLine("Waiting for a connection.....");
         cl = myList.AcceptTcpClient();          // dés qu'il y a une connection on peut passer a la suite
         Console.WriteLine("Connection accepted from " + cl.Client.RemoteEndPoint);
         stm = cl.GetStream(); // le flux de données est créé
      }
      catch (Exception e)
     {
         Console.WriteLine("Error..... " + e.StackTrace);
         Console.ReadLine();
     }
     th1 = new Thread(Launch); // on lance le thread qui va lire le flux
     th1.Name = "Serveur";
     th1.Start();
 }
Example #22
0
 public TcpServer(IPAddress ip, int port)
 {
     this.Port = port;
     this.Ip = ip;
     server = new TcpClient(new IPEndPoint(Ip, Port));
     ns = server.GetStream();
 }
Example #23
0
 public void certConnectReply(byte[] packet, NetworkStream client)
 {
     // Just send the viewData
     byte[] response = { 0x04, 0x00, 0x00, 0x00, 0x00 };
     byte[] encryptedResponse = marginEncr.encrypt(response);
     sendTCPVariableLenPacket(encryptedResponse, client);
 }
Example #24
0
 public static void Main()
 {
     TcpListener tcpListener = new TcpListener(10);
     tcpListener.Start();
     Socket socketForClient = tcpListener.AcceptSocket();
     if (socketForClient.Connected)
     {
         Console.WriteLine("Client connected");
         NetworkStream networkStream = new NetworkStream(socketForClient);
         System.IO.StreamWriter streamWriter =
         new System.IO.StreamWriter(networkStream);
         System.IO.StreamReader streamReader =
         new System.IO.StreamReader(networkStream);
         string theString = "Sending";
         streamWriter.WriteLine(theString);
         Console.WriteLine(theString);
         streamWriter.Flush();
         theString = streamReader.ReadLine();
         Console.WriteLine(theString);
         streamReader.Close();
         networkStream.Close();
         streamWriter.Close();
     }
     socketForClient.Close();
     Console.WriteLine("Exiting...");
 }
Example #25
0
	static string PostStream (Mono.Security.Protocol.Tls.SecurityProtocolType protocol, string url, byte[] buffer)
	{
		Uri uri = new Uri (url);
		string post = "POST " + uri.AbsolutePath + " HTTP/1.0\r\n";
		post += "Content-Type: application/x-www-form-urlencoded\r\n";
		post += "Content-Length: " + (buffer.Length + 5).ToString () + "\r\n";
		post += "Host: " + uri.Host + "\r\n\r\n";
		post += "TEST=";
		byte[] bytes = Encoding.Default.GetBytes (post);

		IPHostEntry host = Dns.Resolve (uri.Host);
		IPAddress ip = host.AddressList [0];
		Socket socket = new Socket (ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
		socket.Connect (new IPEndPoint (ip, uri.Port));
		NetworkStream ns = new NetworkStream (socket, false);
		SslClientStream ssl = new SslClientStream (ns, uri.Host, false, protocol);
		ssl.ServerCertValidationDelegate += new CertificateValidationCallback (CertificateValidation);

		ssl.Write (bytes, 0, bytes.Length);
		ssl.Write (buffer, 0, buffer.Length);
		ssl.Flush ();

		StreamReader reader = new StreamReader (ssl, Encoding.UTF8);
		string result = reader.ReadToEnd ();
		int start = result.IndexOf ("\r\n\r\n") + 4;
		start = result.IndexOf ("\r\n\r\n") + 4;
		return result.Substring (start);
	}
Example #26
0
    /// <summary>
    /// 连接上服务器
    /// </summary>
    void OnConnect(IAsyncResult asr)
    {
        outStream = client.GetStream();
        client.GetStream().BeginRead(byteBuffer, 0, MAX_READ, new AsyncCallback(OnRead), null);
        
		//TODO: NOTIFY connected
    }
        public void TestCustomProtocol()
        {
            EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);

            using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
            {
                socket.Connect(serverAddress);

                var socketStream = new NetworkStream(socket);
                var reader = new StreamReader(socketStream, Encoding.ASCII, false);
                var writer = new StreamWriter(socketStream, Encoding.ASCII, 1024);

                string charSource = Guid.NewGuid().ToString().Replace("-", string.Empty)
                    + Guid.NewGuid().ToString().Replace("-", string.Empty)
                    + Guid.NewGuid().ToString().Replace("-", string.Empty);

                Random rd = new Random();

                for (int i = 0; i < 10; i++)
                {
                    int startPos = rd.Next(0, charSource.Length - 2);
                    int endPos = rd.Next(startPos + 1, charSource.Length - 1);

                    var currentMessage = charSource.Substring(startPos, endPos - startPos + 1);

                    writer.Write("ECHO {0} {1}", currentMessage.Length.ToString().PadLeft(4, '0'), currentMessage);
                    writer.Flush();

                    var line = reader.ReadLine();
                    Console.WriteLine("Received: " + line);
                    Assert.AreEqual(currentMessage, line);
                }
            }
        }
Example #28
0
        public Boolean Connect(String ip, int port)
        {
            try
            {
                TcpClient = new System.Net.Sockets.TcpClient();
                TcpClient.ReceiveTimeout = 5000;
                TcpClient.SendTimeout = 5000;
                TcpClient.Connect(ip, port);
                Ns = TcpClient.GetStream();

                Bw = new BinaryWriter(TcpClient.GetStream());
                Br = new BinaryReader(TcpClient.GetStream());

                IsConnected = true;
            }
            catch (Exception e)
            {
                IsConnected = false;
                Log.Cl(e.Message);
                return false;
            }

            ReceptionThread = new Thread(new ThreadStart(Run));
            ReceptionThread.IsBackground = true;
            ReceptionThread.Start();

            return true;
        }
Example #29
0
        public void TestBatchRequest()
        {
            using (var socket = CreateClient())
            {
                var socketStream = new NetworkStream(socket);
                using (var reader = new StreamReader(socketStream, Encoding.ASCII, true))
                using (var writer = new ConsoleWriter(socketStream, Encoding.ASCII, 1024 * 8))
                {
                    reader.ReadLine();

                    int size = 100;

                    var lines = new string[size];

                    for (var i = 0; i < size; i++)
                    {
                        var line = Guid.NewGuid().ToString();
                        lines[i] = line;
                        var request = CreateRequest(line);
                        writer.Write(request);
                    }

                    writer.Flush();

                    for (var i = 0; i < size; i++)
                    {
                        var receivedLine = reader.ReadLine();
                        Assert.AreEqual(lines[i], receivedLine);
                    }
                }
            }
        }
        public void HandShake()
        {
            try
            {
                client = new TcpClient(server, port);

                string hello = "HELLO";

                data = System.Text.Encoding.ASCII.GetBytes(hello);

                stream = client.GetStream();
                stream.Write(data, 0, data.Length);

                int i = stream.Read(bytes, 0, bytes.Length);
                string Data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);

                if (Data == "HI")
                {
                    //MessageBox.Show("Підключення з сервером встановлено успішно.");
                    isConnected = true;
                    toolStripMenuItem3.Enabled = true;
                    toolStripMenuItem1.Enabled = false;
                }
                else
                {
                    MessageBox.Show("Невдалось підключитись до сервера. Спробуйте пізніше.\n");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Невдалось підключитись до сервера. Спробуйте пізніше.\n\n" + ex.ToString());
            }
        }
Example #31
0
        static void Main(string[] args)
        {
            try {
                string Name    = string.Empty;
                string Subject = string.Empty;
                Int32  Grade   = 0;
                string Memo    = string.Empty;

                do
                {
                    // 1. 데이타 입력
                    Console.Write("이름 : ");
                    Name = Console.ReadLine();

                    Console.Write("과목 : ");
                    Subject = Console.ReadLine();

                    Console.Write("점수 : ");
                    string tmpGrage = Console.ReadLine();
                    if (tmpGrage != "")
                    {
                        int outGrade = 0;
                        if (Int32.TryParse(tmpGrage, out outGrade))
                        {
                            Grade = Convert.ToInt32(tmpGrage);
                        }
                        else
                        {
                            Grade = 0;
                        }
                    }
                    else
                    {
                        Grade = 0;
                    }

                    Console.Write("메모 : ");
                    Memo = Console.ReadLine();

                    if (string.IsNullOrEmpty(Name) || string.IsNullOrEmpty(Subject))
                    {
                        break;
                    }

                    DataPacket packet = new DataPacket();
                    packet.Name    = Name;
                    packet.Subject = Subject;
                    packet.Grade   = Grade;
                    packet.Memo    = Memo;

                    byte[] buffer = GetBytes_Bind(packet);

                    TcpClient client = new TcpClient();
                    client.Connect("192.168.254.1", 13000);
                    Console.WriteLine("Connected...");

                    NetworkStream stream = client.GetStream();

                    stream.Write(buffer, 0, buffer.Length);
                    Console.WriteLine("{0} data sent\n", buffer.Length);

                    stream.Close();
                    client.Close();
                } while (Name != "" && Subject != "");
            } catch (SocketException se) {
                Console.WriteLine("SocketException : {0} ", se.Message.ToString());
            } catch (Exception ex) {
                Console.WriteLine("Exception : {0} ", ex.Message.ToString());
            }

            Console.WriteLine("press the ENTER to continue...");
            Console.ReadLine();
        }
Example #32
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="serverName">Server name</param>
        /// <param name="port">TCP port number</param>
        /// <param name="timerExpire">Connection timer expiration</param>
        /// <param name="callbackObject">Callback object</param>
        public SNITCPHandle(string serverName, int port, long timerExpire, object callbackObject, bool parallel)
        {
            _writeScheduler   = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler;
            _writeTaskFactory = new TaskFactory(_writeScheduler);
            _callbackObject   = callbackObject;
            _targetServer     = serverName;

            try
            {
                TimeSpan ts = default(TimeSpan);

                // In case the Timeout is Infinite, we will receive the max value of Int64 as the tick count
                // The infinite Timeout is a function of ConnectionString Timeout=0
                bool isInfiniteTimeOut = long.MaxValue == timerExpire;
                if (!isInfiniteTimeOut)
                {
                    ts = DateTime.FromFileTime(timerExpire) - DateTime.Now;
                    ts = ts.Ticks < 0 ? TimeSpan.FromTicks(0) : ts;
                }

                Task <Socket> connectTask;
                if (parallel)
                {
                    Task <IPAddress[]> serverAddrTask = Dns.GetHostAddressesAsync(serverName);
                    serverAddrTask.Wait(ts);
                    IPAddress[] serverAddresses = serverAddrTask.Result;

                    if (serverAddresses.Length > MaxParallelIpAddresses)
                    {
                        // Fail if above 64 to match legacy behavior
                        ReportTcpSNIError(0, SNICommon.MultiSubnetFailoverWithMoreThan64IPs, string.Empty);
                        return;
                    }

                    connectTask = ParallelConnectAsync(serverAddresses, port);
                }
                else
                {
                    connectTask = ConnectAsync(serverName, port);
                }

                if (!(isInfiniteTimeOut ? connectTask.Wait(-1) : connectTask.Wait(ts)))
                {
                    ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, string.Empty);
                    return;
                }

                _socket = connectTask.Result;
                if (_socket == null || !_socket.Connected)
                {
                    if (_socket != null)
                    {
                        _socket.Dispose();
                        _socket = null;
                    }
                    ReportTcpSNIError(0, SNICommon.ConnOpenFailedError, string.Empty);
                    return;
                }

                _socket.NoDelay = true;
                _tcpStream      = new NetworkStream(_socket, true);

                _sslOverTdsStream = new SslOverTdsStream(_tcpStream);
                _sslStream        = new SslStream(_sslOverTdsStream, true, new RemoteCertificateValidationCallback(ValidateServerCertificate), null);
            }
            catch (SocketException se)
            {
                ReportTcpSNIError(se);
                return;
            }
            catch (Exception e)
            {
                ReportTcpSNIError(e);
                return;
            }

            _stream = _tcpStream;
            _status = TdsEnums.SNI_SUCCESS;
        }
Example #33
0
        public async Task ConnectAsync_DnsEndPoint_Success(int mode)
        {
            using (var client = new DerivedTcpClient())
            {
                Assert.False(client.Connected);
                Assert.False(client.Active);

                string host = System.Net.Test.Common.Configuration.Sockets.SocketServer.IdnHost;
                int    port = System.Net.Test.Common.Configuration.Sockets.SocketServer.Port;

                IPAddress[] addresses;
                switch (mode)
                {
                case 0:
                    await client.ConnectAsync(host, port);

                    break;

                case 1:
                    addresses = await Dns.GetHostAddressesAsync(host);

                    await client.ConnectAsync(addresses[0], port);

                    break;

                case 2:
                    addresses = await Dns.GetHostAddressesAsync(host);

                    await client.ConnectAsync(addresses, port);

                    break;

                case 3:
                    await Task.Factory.FromAsync(client.BeginConnect, client.EndConnect, host, port, null);

                    break;

                case 4:
                    addresses = await Dns.GetHostAddressesAsync(host);

                    await Task.Factory.FromAsync(client.BeginConnect, client.EndConnect, addresses[0], port, null);

                    break;

                case 5:
                    addresses = await Dns.GetHostAddressesAsync(host);

                    await Task.Factory.FromAsync(client.BeginConnect, client.EndConnect, addresses, port, null);

                    break;
                }

                Assert.True(client.Active);
                Assert.True(client.Connected);
                Assert.NotNull(client.Client);
                Assert.Same(client.Client, client.Client);

                using (NetworkStream s = client.GetStream())
                {
                    byte[] getRequest = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\n\r\n");
                    await s.WriteAsync(getRequest, 0, getRequest.Length);

                    Assert.NotEqual(-1, s.ReadByte()); // just verify we successfully get any data back
                }
            }
        }
Example #34
0
        private async Task ProcessClientAsync(TcpClient tcpClient)
        {
            try
            {
                using (NetworkStream stream = tcpClient.GetStream())
                {
                    List <byte> data = new List <byte>();

                    int position = 0;

                    byte[] buffer = new byte[HttpConstants.BUFFER_SIZE];

                    while (true)
                    {
                        int count =
                            await stream.ReadAsync(buffer, position, buffer.Length);

                        position += count;

                        if (count < buffer.Length)
                        {
                            var partialBuffer = new byte[count];

                            Array.Copy(buffer, partialBuffer, count);

                            data.AddRange(partialBuffer);

                            break;
                        }
                        else
                        {
                            data.AddRange(buffer);
                        }
                    }

                    var requestAsString = Encoding.UTF8.GetString(data.ToArray());

                    var request = new HttpRequest(requestAsString);

                    Console.WriteLine($"{request.Method} {request.Path} => {request.Headers.Count} headers");

                    HttpResponse response;

                    var route = this.routeTable.FirstOrDefault(
                        x => string.Compare(x.Path, request.Path, true) == 0 &&
                        x.Method == request.Method);

                    if (route != null)
                    {
                        response = route.Action(request);
                    }
                    else
                    {
                        response = new HttpResponse("text/html", new byte[0], HttpStatusCode.NotFound);
                    }

                    response.Headers.Add(new Header("Server", "SUS Server 1.0"));

                    var sessionCookie = request.Cookies.FirstOrDefault(x => x.Name == HttpConstants.SESSION_COOKIE_NAME);

                    if (sessionCookie != null)
                    {
                        var responseSessionCookie = new ResponseCookie(sessionCookie.Name, sessionCookie.Value);

                        responseSessionCookie.Path = "/";

                        response.Cookies.Add(responseSessionCookie);
                    }

                    var responseHeaderBytes = Encoding.UTF8.GetBytes(response.ToString());

                    await stream.WriteAsync(responseHeaderBytes, 0, responseHeaderBytes.Length);

                    if (response.Body != null)
                    {
                        await stream.WriteAsync(response.Body, 0, response.Body.Length);
                    }
                }

                tcpClient.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }
Example #35
0
        private void ThreadRun()
        {
            Console.WriteLine(DateTime.Now + " Client thread started");
            NetworkStream stream       = this.client.GetStream();
            BinaryReader  binaryReader = new BinaryReader(stream);
            BinaryWriter  binaryWriter = new BinaryWriter(stream);
            FileStream    fileStream   = null;
            string        text         = "";

            try
            {
                while (true)
                {
                    byte b = binaryReader.ReadByte();
                    long offset;
                    int  num;
                    switch (b)
                    {
                    case 0:
                    {
                        text = binaryReader.ReadString().Trim();
                        FileMode fileMode = (FileMode)binaryReader.ReadByte();
                        Console.WriteLine(string.Concat(new object[]
                            {
                                DateTime.Now,
                                " Open file ",
                                text,
                                " in ",
                                fileMode,
                                " mode"
                            }));
                        lock (this.fileManager)
                        {
                            fileStream = this.fileManager.GetFile(text, fileMode);
                            binaryWriter.Write(fileStream.Length);
                            break;
                        }
                        goto IL_10B;
                    }

                    case 1:
                        goto IL_10B;

                    case 2:
                        goto IL_16B;

                    case 3:
                    {
                        offset = binaryReader.ReadInt64();
                        num    = binaryReader.ReadInt32();
                        byte[] buffer = new byte[8192];
                        int    num2   = num;
                        lock (fileStream)
                        {
                            fileStream.Seek(offset, SeekOrigin.Begin);
                            while (num != 0)
                            {
                                int num3;
                                if (num2 < 8192)
                                {
                                    num3 = stream.Read(buffer, 0, num2);
                                }
                                else
                                {
                                    num3 = stream.Read(buffer, 0, 8192);
                                }
                                if (num3 == 0)
                                {
                                    break;
                                }
                                num2 -= num3;
                                fileStream.Write(buffer, 0, num3);
                            }
                        }
                        break;
                    }

                    case 4:
                        Console.WriteLine(DateTime.Now + " Flush file " + text);
                        lock (fileStream)
                        {
                            fileStream.Flush();
                            break;
                        }
                        goto IL_16B;
                    }
IL_250:
                    if (b == 1)
                    {
                        break;
                    }
                    continue;
IL_10B:
                    Console.WriteLine(DateTime.Now + " Close file " + text);
                    goto IL_250;
IL_16B:
                    offset = binaryReader.ReadInt64();
                    num    = binaryReader.ReadInt32();
                    byte[] buffer2 = new byte[num];
                    lock (fileStream)
                    {
                        fileStream.Seek(offset, SeekOrigin.Begin);
                        fileStream.Read(buffer2, 0, num);
                    }
                    stream.Write(buffer2, 0, num);
                    goto IL_250;
                }
            }
            catch (Exception value)
            {
                Console.WriteLine(DateTime.Now + " ServerClient exception. Connection closed.");
                Console.WriteLine(value);
            }
            finally
            {
                Console.WriteLine(DateTime.Now + " DataFileServerClient::Finally");
                if (fileStream != null)
                {
                    lock (fileStream)
                    {
                        fileStream.Flush();
                    }
                }
                this.client.Close();
            }
        }
Example #36
0
        private void CallbackMethod(IAsyncResult ar)
        {
            isConnected = false;
            TcpClient tcpclient = ar.AsyncState as TcpClient;

            if (tcpclient.Client == null)
            {
                return;
            }
            try
            {
                tcpclient.EndConnect(ar);
            }
            catch (SocketException ex)
            {
                RaiseSocketExceptionEvent(new TokenEventArgs(new string[] { "main", ex.Message }));
                return;
            }
            isConnected = true;

            NetworkStream stream = tcpclient.GetStream();
            StreamReader  reader = new StreamReader(stream);

            writer = new StreamWriter(stream);
            string inputLine;

            writer.WriteLine($"USER {nickname} 0 * :{nickname}");
            writer.Flush();
            writer.WriteLine($"NICK {nickname}");
            writer.Flush();
            while (true)
            {
                while (tcpclient.Connected && (inputLine = reader.ReadLine()) != null)
                {
                    #if DEBUG
                    Console.WriteLine("<- " + inputLine);
                    #endif
                    string[] tokens = inputLine.Split(new char[] { ' ' });
                    if (tokens.Length < 2)
                    {
                        continue;
                    }
                    if (tokens[0] == "PING")
                    {
                        string key = tokens[1];
                        #if DEBUG
                        Console.WriteLine("-> PONG " + key);
                        #endif
                        writer.WriteLine("PONG " + key);
                        writer.Flush();
                        continue;
                    }
                    switch (tokens[1])
                    {
                    /*case "001":
                     *  ChangeNick(tokens[2]);
                     *  break;*/
                    case "PRIVMSG":
                        RaisePrivMsgEvent(new TokenEventArgs(tokens));
                        break;

                    case "NOTICE":
                        RaiseNoticeEvent(new TokenEventArgs(tokens));
                        break;

                    case "NICK":
                        RaiseNickEvent(new TokenEventArgs(tokens));
                        break;

                    case "JOIN":
                        RaiseJoinEvent(new TokenEventArgs(tokens));
                        break;

                    case "PART":
                        RaisePartEvent(new TokenEventArgs(tokens));
                        break;

                    case "QUIT":
                        RaiseQuitEvent(new TokenEventArgs(tokens));
                        break;

                    case "MODE":
                        RaiseModeEvent(new TokenEventArgs(tokens));
                        break;

                    case "332":     // topic
                        RaiseTopicEvent(new TokenEventArgs(tokens));
                        break;

                    case "353":     // userlist
                        RaiseUserEvent(new TokenEventArgs(tokens));
                        break;

                    default:
                        RaiseDefaultEvent(new TokenEventArgs(tokens));
                        break;
                    }
                }
                writer.Close();
                reader.Close();
                tcpclient.Close();
                isConnected = false;
                RaiseDisconnectEvent(EventArgs.Empty);
            }
        }
 public NetworkCommunication(NetworkStream networkStream)
 {
     _networkStream = networkStream;
 }
        /// <summary>
        /// holderUser, control the whole flow of reacting to one user
        /// </summary>
        /// <param name="filterInfo"> one string contains the filter information sent by user </param>
        static private void holdUser(Socket connection)
        {
            if (LogAdded != null)
            {
                LogAdded(null, string.Format("one user connected, IP: {0}\r\n", connection.RemoteEndPoint.ToString()));
            }
            if (ClientChange != null)
            {
                ClientChange(null, 1);
            }
            QueryInfo parsedInfo;
            string    filterInfo;
            bool      conditionRequired;

            //set time out
            connection.ReceiveTimeout = 2000;
            connection.SendTimeout    = 5000;
            //receive filter information from client
            byte[] receivedBytes = new Byte[1024];
            int    bytesGet      = connection.Receive(receivedBytes);

            filterInfo = Encoding.UTF8.GetString(receivedBytes, 0, bytesGet);
            //create a XML writer
            XmlWriterSettings settings = new XmlWriterSettings()
            {
                Encoding = Encoding.UTF8
            };
            NetworkStream targetStream = new NetworkStream(connection);
            XmlWriter     writer       = XmlWriter.Create(targetStream, settings);

            try
            {
                parsedInfo = parseInfo(filterInfo, out conditionRequired);

                if (conditionRequired)
                {
                    InfoRefresher.SendConditionAsXML(writer, parsedInfo.RoomName);
                }
                else
                {
                    /*
                     * var filter = new System.Threading.Tasks.Dataflow.TransformBlock<QueryInfo, IEnumerable<RoomInfo>>(
                     *    (info) => Query.Filter(info));
                     * var transform = new System.Threading.Tasks.Dataflow.ActionBlock<IEnumerable<RoomInfo>>(
                     *    (rooms) => TransferResult(rooms, writer));
                     * filter.LinkTo(transform, new DataflowLinkOptions());
                     *
                     * filter.Post(parsedInfo);*/
                    RoomInfo[] results = Query.Filter(parsedInfo);
                    TransferResult(results, writer);
                    writer.Flush();
                }
            }
            catch (FormatException ex)
            {
                writer.WriteStartDocument();
                writer.WriteElementString("Error", ex.Message.ToString());
                writer.Flush();
                //To-do: requirement sent from user is in wrong syntax, handle this
            }
            catch (ArgumentNullException ex)
            {
                writer.WriteStartDocument();
                writer.WriteElementString("Error", ex.Message.ToString());
                writer.Flush();
            }
            catch (TimeoutException ex)
            {
                writer.WriteStartDocument();
                writer.WriteElementString("Error", "time out");
                writer.Flush();
            }
            catch (System.IO.FileNotFoundException ex)
            {
                writer.WriteStartDocument();
                writer.WriteElementString("Error", "the condition has not been parsed");
                writer.Flush();
            }
            catch (System.IO.IOException)
            {
                //the remote host closed connection
            }
            finally
            {
                if (LogAdded != null)
                {
                    LogAdded(null, string.Format("user {0} disconnected\r\n", connection.RemoteEndPoint.ToString()));
                }
                if (ClientChange != null)
                {
                    ClientChange(null, -1);
                }
                writer.Close();
                connection.Close();
            }
        }
Example #39
0
        /// <summary>
        /// Handle a massage got from the client, and respone appropriately
        /// </summary>
        /// <param name="client"> the client</param>

        public void HandleClient(TcpClient client)
        {
            new Task(() =>
            {
                // m_logging.Log("Got new connection! ClientId: " + (++clientsId), MessageTypeEnum.INFO);
                bool connectionIsOn          = true; //Right now connection will be always on, but Maybe in future we will change it
                NetworkStream stream         = client.GetStream();
                BinaryReader reader          = new BinaryReader(stream);
                BinaryWriter writer          = new BinaryWriter(stream);
                ClientInformation clientInfo = new ClientInformation(stream, reader, writer, client);
                clientInfo.id = clientsId;
                m_allClients.Add(clientInfo);

                try
                {
                    while (connectionIsOn)
                    {
                        //Read command from client and Derserialize it
                        TCPEventArgs e = JsonConvert.DeserializeObject <TCPEventArgs>(reader.ReadString());
                        // m_logging.Log("Got Massage!!!: " + e.CommandID + " " + e.Args, MessageTypeEnum.INFO);
                        TCPEventArgs toSend;
                        string[] args = { e.Args };

                        bool success;
                        string result = m_controller.ExecuteCommand(e.CommandID, args, out success);
                        if (!success)
                        {
                            toSend = new TCPEventArgs((int)CommandEnum.ErrorOccurred, null);
                        }
                        else
                        {
                            toSend = new TCPEventArgs(e.CommandID, result);
                        }

                        //    m_logging.Log("Send: " + toSend.Args, MessageTypeEnum.INFO);

                        //Serialize the command to send, and send it
                        string serialized = JsonConvert.SerializeObject(toSend);
                        if (e.CommandID == (int)CommandEnum.CloseCommand)
                        {
                            if (success)
                            {
                                broadcastAllClients(serialized);
                                continue;
                            }
                        }
                        //If write won't success, we catch the execption, and then we close the client and remove it.
                        m_mutex.WaitOne();
                        writer.Write(serialized);
                        m_mutex.ReleaseMutex();
                        // m_logging.Log("Sent to client: " + toSend.Args, MessageTypeEnum.INFO);
                    }
                }

                catch (Exception)
                {
                    connectionIsOn = false;
                }
                m_allClients.Remove(clientInfo);
                client.Close();
                string logMassege = "Client " + clientInfo.id + " Disconnected";
                //m_logging.Log(logMassege, MessageTypeEnum.WARNING);
            }).Start();
        }
Example #40
0
        void Accept(TcpClient client)
        {
            client.ReceiveBufferSize = 0;
            client.SendBufferSize    = NetworkClient.Config.BufferSize;
            using (NetworkStream ns = client.GetStream())
            {
                BufferedStream n = new BufferedStream(ns, NetworkClient.Config.BufferSize);
                {
                    byte[] hdr = new byte[5];
                    n.Read(hdr, 0, 5);
                    int    count     = BitConverter.ToInt32(hdr, 1);
                    byte[] data      = new byte[count];
                    int    bytesRead = 0;
                    int    chunksize = 1;
                    while (bytesRead < count && chunksize > 0)
                    {
                        bytesRead    +=
                            chunksize = n.Read
                                            (data, bytesRead, count - bytesRead);
                    }
#if minilzo
                    if ((hdr[0] & (byte)4) == (byte)4)
                    {
                        data = RaptorDB.MiniLZO.Decompress(data);
                    }
#endif
                    object o = fastBinaryJSON.BJSON.ToObject(data);
                    // handle payload
                    object r          = _handler(o);
                    bool   compressed = false;
                    var    dataret    = fastBinaryJSON.BJSON.ToBJSON(r);
#if minilzo
                    if (dataret.Length > NetworkClient.Config.CompressDataOver)
                    {
                        log.Info("compressing data over limit : " + dataret.Length.ToString("#,#"));
                        compressed = true;
                        dataret    = RaptorDB.MiniLZO.Compress(dataret);
                        log.Info("new size : " + dataret.Length.ToString("#,#"));
                    }
                    if (dataret.Length > NetworkClient.Config.LogDataSizesOver)
                    {
                        log.Info("data size (bytes) = " + dataret.Length.ToString("#,#"));
                    }
#endif
                    byte[] len = Helper.GetBytes(dataret.Length, false);
                    // header
                    n.WriteByte((byte)((true ? 3 : 0) + (compressed ? 4 : 0)));
                    n.Write(len, 0, 4);
                    // data
                    n.Write(dataret, 0, dataret.Length);
                    n.Flush();
                    //n.Close();

                    //client.Close();
                    //int wait = 0;
                    //bool close = false;
                    //var dt = FastDateTime.Now;
                    //while (n.DataAvailable == false && close == false)
                    //{
                    //    wait++;
                    //    if (wait < 10000) // kludge : for insert performance
                    //        Thread.Sleep(0);
                    //    else
                    //    {
                    //        Thread.Sleep(1);
                    //        // wait done -> close connection
                    //        if (FastDateTime.Now.Subtract(dt).TotalSeconds > NetworkClient.Config.KillConnectionSeconds)
                    //            close = true;
                    //    }
                    //}
                    //if (close)
                    //    break;
                }
            }
            client.Close();
        }
Example #41
0
        private static void MessageHandler(NetworkStream stream)
        {
            string[] data;
            Account  newUser = new Account();

            data = Recieve(stream);

            if (data[0] == "reg")
            {
                newUser.username = data[1];
                newUser.password = data[2];

                Account.registeredAccounts.Add(newUser);

                StreamWriter writer = File.AppendText("users.txt");
                writer.WriteLine(data[1] + "\\" + data[2]);

                writer.Close();
                Console.WriteLine("[" + DateTime.Today + "] " + data[1] + " has registered!");
            }
            else if (data[0] == "administration")
            {
                newUser.username = "******";
                newUser.password = "******";

                if (!Account.CheckAcc(newUser, data[0], data[1]))
                {
                    SendData(stream, "False\\Incorrect admin password");
                    return;
                }

                switch (data[2])
                {
                case "ping":
                    SendData(stream, "True");
                    break;

                case "getreg":
                    StringBuilder builder = new StringBuilder();
                    foreach (var regUser in File.ReadAllLines("users.txt"))
                    {
                        builder.Append("\\" + regUser);
                    }

                    SendData(stream, "True" + builder.ToString());
                    break;

                case "remusr":
                    string[] users = UserParser.GetUsers();

                    foreach (var user in  users)
                    {
                        string[] splitted = UserParser.ParseUserInfo(user);

                        if (splitted[0] == data[3])
                        {
                            List <string> temp = users.ToList();

                            temp.Remove(user);

                            File.WriteAllLines("users.txt", temp.ToArray());

                            SendData(stream, "True");
                        }
                    }
                    break;

                case "addusr":
                    StreamWriter writer = File.AppendText("users.txt");
                    writer.WriteLine(data[3] + "\\" + data[4]);
                    writer.Close();

                    SendData(stream, "True");
                    break;

                case "getusr":
                    if (!UserParser.Exists(data[3]))
                    {
                        SendData(stream, "User does not exist");
                        return;
                    }

                    string userInfo = UserParser.FindUser(data[3]);

                    SendData(stream, "True\\" + userInfo);
                    break;

                default:
                    SendData(stream, "False\\Command does not exist");
                    break;
                }

                return;
            }
            else
            {
                string errorCode = "Incorrect username or password";
                bool   result    = false;

                foreach (var registered in Account.registeredAccounts)
                {
                    if (Account.CheckAcc(registered, data[1], data[2]))
                    {
                        if (onlineUsers.Exists(on => on.username == registered.username))
                        {
                            errorCode = "User is already logged in";
                            break;
                        }
                        SendData(stream, "True");

                        newUser.username = data[1];
                        newUser.password = data[2];
                        newUser.stream   = stream;

                        onlineUsers.Add(newUser);

                        result = true;
                        Console.WriteLine("[" + DateTime.Today + "] " + data[1] + " has connected");
                        SendServerMsg($"{newUser.username} has connected");

                        break;
                    }
                }

                if (!result)
                {
                    SendData(stream, "False\\" + errorCode);
                    return;
                }

                while (true)
                {
                    data = Recieve(stream);

                    switch (data[0])
                    {
                    case "msg":
                        if (!Account.CheckAcc(newUser, data[1], data[2]))
                        {
                            return;
                        }

                        MsgInfo info = new MsgInfo();

                        info.user    = newUser;
                        info.message = data[3];
                        Console.WriteLine("[" + DateTime.Today + "] " + info.user + ": " + info.message);
                        msgQueue.Add(info);
                        break;

                    case "exit":
                        if (!Account.CheckAcc(newUser, data[1], data[2]))
                        {
                            return;
                        }

                        foreach (var user in onlineUsers)
                        {
                            if (user.username == data[1])
                            {
                                onlineUsers.Remove(user);
                                Console.WriteLine("[" + DateTime.Today + "] " + data[1] + " has disconnected");
                                SendServerMsg($"{user.username} has disconnected");
                            }
                        }

                        break;
                    }
                }
            }
        }
        static void Main(string[] args)
        {
            Console.Title = "Client";
            Console.WriteLine("Starting echo client...");

            int       port = 12346, match = 0;
            Int32     portt = 13000;
            string    a = "", b = "";
            TcpClient client = null;

            while (match == 0)
            {
                Console.WriteLine("Please enter the server address");
                a = Console.ReadLine();
                //a = "127.0.0.1";
                Console.WriteLine("Please enter the port number");
                b     = Console.ReadLine();
                portt = Convert.ToInt32(b);

                IPAddress localAddr = IPAddress.Parse(a);

                try
                {
                    client = new TcpClient(localAddr.ToString(), portt);
                    match  = 1;
                    Console.WriteLine("Connection established successfully!");
                }
                catch {
                    match  = 0;
                    client = null;
                    Console.WriteLine("Unable to establish connection!");
                }
            }


            NetworkStream stream = client.GetStream();
            StreamReader  reader = new StreamReader(stream);
            StreamWriter  writer = new StreamWriter(stream)
            {
                AutoFlush = true
            };

            while (true)
            {
                Console.Write("Enter text to send: ");
                string lineToSend = "";
                lineToSend += Console.ReadLine();


                writer.WriteLine(lineToSend);
                if (lineToSend != "end-of-session")
                {
                    Console.WriteLine("Sending to server: " + lineToSend);
                    string lineReceived = reader.ReadLine();
                    Console.WriteLine("Server response: " + lineReceived);
                }
                else
                {
                    Console.WriteLine("Good Bye");
                    Thread.Sleep(1000);
                    return;
                }
            }
            client.Close();
        }
Example #43
0
        private static void SendData(NetworkStream stream, string data)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(data + "\\");

            stream.Write(bytes, 0, bytes.Length);
        }
Example #44
0
        private static void Handle(TcpClient client)
        {
            NetworkStream stream = client.GetStream();

            MessageHandler(stream);
        }
Example #45
0
        public void Can_connect_to_Buffered_SslStream()
        {
            var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
            {
                SendTimeout    = -1,
                ReceiveTimeout = -1,
            };

            socket.Connect(Host, Port);

            if (!socket.Connected)
            {
                socket.Close();
                throw new Exception("Could not connect");
            }

            Stream networkStream = new NetworkStream(socket);

            SslStream sslStream;

            if (Env.IsMono)
            {
                //Mono doesn't support EncryptionPolicy
                sslStream = new SslStream(networkStream,
                                          leaveInnerStreamOpen: false,
                                          userCertificateValidationCallback: RedisConfig.CertificateValidationCallback,
                                          userCertificateSelectionCallback: RedisConfig.CertificateSelectionCallback);
            }
            else
            {
                var ctor = typeof(SslStream).GetConstructors()
                           .First(x => x.GetParameters().Length == 5);

                var policyType  = AssemblyUtils.FindType("System.Net.Security.EncryptionPolicy");
                var policyValue = Enum.Parse(policyType, "RequireEncryption");

                sslStream = (SslStream)ctor.Invoke(new[] {
                    networkStream,
                    false,
                    RedisConfig.CertificateValidationCallback,
                    RedisConfig.CertificateSelectionCallback,
                    policyValue,
                });

                //sslStream = new SslStream(networkStream,
                //    leaveInnerStreamOpen: false,
                //    userCertificateValidationCallback: null,
                //    userCertificateSelectionCallback: null,
                //    encryptionPolicy: EncryptionPolicy.RequireEncryption);
            }

#if NETCORE
            sslStream.AuthenticateAsClientAsync(Host).Wait();
#else
            sslStream.AuthenticateAsClient(Host);
#endif

            if (!sslStream.IsEncrypted)
            {
                throw new Exception("Could not establish an encrypted connection to " + Host);
            }

            var bstream = new System.IO.BufferedStream(sslStream, 16 * 1024);

            SendAuth(bstream);
        }
Example #46
0
 public static void Close(this NetworkStream stream)
 {
     stream.Flush();
 }
        /*
        *FUNCTION		: ListenAndRespond
        *PARAMETERS		: ref TcpListener server: server that listen client
        *RETURNS		: no return
        *DESCRIPTION	: This method accept client and create a stream, through the stream it communicate with client
        *                  It enters infinite loop to get clients message in try block, if the stream has problem with connection
        *                  it throws exception.
        */
        public void ListenAndRespond(ref TcpListener server)
        {
            // Buffer for reading data
            Byte[] bytes = new Byte[10240];
            String request = null;

            try
            {
                // Enter the listening loop.
                while (true)
                {
                    //Console.Write("Waiting for a connection... ");

                    // Perform a blocking call to accept requests.
                    // You could also user server.AcceptSocket() here.
                    TcpClient client = server.AcceptTcpClient();
                    //Console.WriteLine("Connected!");

                    request = null;

                    // Get a stream object for reading and writing
                    NetworkStream stream = client.GetStream();

                    int i;

                    // Loop to receive all the data sent by the client.
                    while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
                    {
                        // Translate data bytes to a ASCII string.
                        request = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
                        //Console.WriteLine("Received: {0}", request);

                        // parse the request and return the full response 
                        byte[] respondMsg = ParseRequest(request);


                        //log request header          
                        Logging.WriteLog(HTTPRequestHeader);

                        // string  respondMsg = request.ToUpper();

                        //serialize the response
                        //byte[] msg = System.Text.Encoding.Default.GetBytes(respondMsg);


                        // Send back a response.
                        stream.Write(respondMsg, 0, respondMsg.Length);
                        //Console.WriteLine("Response Sent...");


                        //log response header 
                        Logging.WriteLog(HTTPResponseHeader);
                        //clear the messages
                        HTTPRequestHeader = "";
                        HTTPResponseBody = "";
                        HTTPResponseHeader = "";

                    }

                    // Shutdown and end connection
                    client.Close();
                }
            }

            catch (SocketException e)
            {
                //Console.WriteLine("SocketException: {0}", e.Message);
                Logging.WriteLog($"SocketException: {e.Message}");
            }
            catch (Exception e)
            {
                Logging.WriteLog($"Exception: {e.Message}");
            }


        }
Example #48
0
        public static void InvokeAsync <T>(Api api, Method method, string url, Dictionary <string, string> headers, object data, AsyncCallback <T> callback)
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object t)
            {
                SocketResponse response = null;

                try
                {
                    Uri uri = new Uri(url);
                    int maximumRetryCount = 5;
                    int retry             = 0;

                    while (++retry < maximumRetryCount)
                    {
                        TcpClient client = new TcpClient();
                        client.Connect(uri.Host, uri.Port);
                        using (NetworkStream stream = client.GetStream())
                        {
                            Stream ostream = stream as Stream;
                            if (uri.Scheme.ToLower() == "https")
                            {
                                ostream = new SslStream(stream, false, new RemoteCertificateValidationCallback(ValidateServerCertificate));
                                try
                                {
                                    SslStream ssl = ostream as SslStream;
                                    ssl.AuthenticateAsClient(uri.Host);
                                }
                                catch (System.Exception e)
                                {
                                    BackendlessFault backendlessFault = new BackendlessFault(e);
                                    if (callback != null)
                                    {
                                        callback.ErrorHandler.Invoke(backendlessFault);
                                    }
                                }
                            }

                            WriteToStream(method, uri, headers, data, ostream);
                            response = new SocketResponse();
                            response.ReadFromStream(ostream);
                        }
                        client.Close();

                        switch (response.status)
                        {
                        case 307:
                        case 302:
                        case 301:
                            uri = new Uri(response.GetHeader("Location"));
                            continue;

                        default:
                            retry = maximumRetryCount;
                            break;
                        }
                    }
                }
                catch (System.Exception ex)
                {
                    BackendlessFault backendlessFault = new BackendlessFault(ex);
                    if (callback != null)
                    {
                        callback.ErrorHandler.Invoke(backendlessFault);
                    }
                }

                if (response.status == 200)
                {
                    T result = default(T);
                    string responseJsonString = response.response;
                    if ((api >= Api.COUNTERSERVICE_GET && api <= Api.COUNTERSERVICE_COM_SET) || api == Api.CACHESERVICE_CONTAINS)
                    {
                        result = (T)Convert.ChangeType(responseJsonString, typeof(T));
                    }
                    else
                    {
                        if (string.IsNullOrEmpty(responseJsonString) == false)
                        {
                            result = JsonMapper.ToObject <T>(responseJsonString);
                        }
                    }

                    if (callback != null)
                    {
                        callback.ResponseHandler.Invoke(result);
                    }
                }
                else
                {
                    BackendlessFault fault = null;

                    try
                    {
                        JsonData errorResponse = JsonMapper.ToObject(response.response);
                        int code       = (int)errorResponse["code"];
                        string message = (string)errorResponse["message"];

                        fault = new BackendlessFault(code.ToString(), message, null);
                    }
                    catch (System.Exception ex)
                    {
                        fault = new BackendlessFault(ex);
                    }

                    if (callback != null)
                    {
                        callback.ErrorHandler.Invoke(fault);
                    }
                }
            }));
        }
Example #49
0
 /// <summary>
 /// Releases the managed and unmanaged resources used by the <see cref="AsyncTcpClient"/>.
 /// Closes the connection to the remote host and disabled automatic reconnecting.
 /// </summary>
 public void Dispose()
 {
     AutoReconnect = false;
     tcpClient?.Dispose();
     stream = null;
 }
Example #50
0
        override protected void Connect()
        {
            if (Stopped)
            {
                return;
            }

            mMutex.WaitOne();

            mClient           = new TcpClient(ServerAddress, ServerPort);
            mStream           = mClient.GetStream();
            mStreamReader     = new StreamReader(mStream, System.Text.Encoding.ASCII, false);
            mStreamWriter     = new StreamWriter(mStream, System.Text.Encoding.ASCII);
            mJsonRPCMessageID = 1;

            mStreamWriter.Write(Newtonsoft.Json.JsonConvert.SerializeObject(new Dictionary <string, Object> {
                { "id", mJsonRPCMessageID++ },
                { "method", "mining.subscribe" },
                { "params", new List <string> {
                      "GatelessGateSharp/0.0.1",
                      "EthereumStratum/1.0.0"
                  } }
            }));
            mStreamWriter.Write("\n");
            mStreamWriter.Flush();

            Dictionary <String, Object> response = JsonConvert.DeserializeObject <Dictionary <string, Object> >(mStreamReader.ReadLine());

            mSubsciptionID  = (string)(((JArray)(((JArray)(response["result"]))[0]))[1]);
            mPoolExtranonce = (string)(((JArray)(response["result"]))[1]);
            //MainForm.Logger("Subsciption ID: " + mSubsciptionID);
            //MainForm.Logger("Protocol Version: " + ((JArray)(((JArray)(response["result"]))[0]))[2]); // TODO: Check this.
            //MainForm.Logger("Extranonce: " + mExtranonce);

            // mining.extranonce.subscribe
            mStreamWriter.Write(JsonConvert.SerializeObject(new Dictionary <string, Object> {
                { "id", mJsonRPCMessageID++ },
                { "method", "mining.extranonce.subscribe" },
                { "params", new List <string> {
                  } }
            }));
            mStreamWriter.Write("\n");
            mStreamWriter.Flush();
            response = JsonConvert.DeserializeObject <Dictionary <string, Object> >(mStreamReader.ReadLine());
            //MainForm.Logger("mining.extranonce.subscribe: " + response["result"]); // TODO

            mStreamWriter.Write(JsonConvert.SerializeObject(new Dictionary <string, Object> {
                { "id", mJsonRPCMessageID++ },
                { "method", "mining.authorize" },
                { "params", new List <string> {
                      Username,
                      Password
                  } }
            }));
            mStreamWriter.Write("\n");
            mStreamWriter.Flush();
            response = JsonConvert.DeserializeObject <Dictionary <string, Object> >(mStreamReader.ReadLine());
            if (!(bool)response["result"])
            {
                mMutex.ReleaseMutex();
                throw new Exception("Authorization failed.");
            }

            mMutex.ReleaseMutex();

            mStreamReaderThread = new Thread(new ThreadStart(StreamReaderThread));
            mStreamReaderThread.IsBackground = true;
            mStreamReaderThread.Start();
        }
Example #51
0
 internal WsStream(NetworkStream innerStream)
     : this(innerStream, false)
 {
 }
Example #52
0
        /// <summary>
        /// Runs the client connection asynchronously.
        /// </summary>
        /// <returns>The task object representing the asynchronous operation.</returns>
        public async Task RunAsync()
        {
            bool isReconnected = false;
            int  reconnectTry  = -1;

            do
            {
                reconnectTry++;
                ByteBuffer = new ByteBuffer();
                if (ServerTcpClient != null)
                {
                    // Take accepted connection from listener
                    tcpClient = ServerTcpClient;
                }
                else
                {
                    // Try to connect to remote host
                    var connectTimeout = TimeSpan.FromTicks(ConnectTimeout.Ticks + (MaxConnectTimeout.Ticks - ConnectTimeout.Ticks) / 20 * Math.Min(reconnectTry, 20));
                    tcpClient = new TcpClient(AddressFamily.InterNetworkV6);
                    tcpClient.Client.DualMode = true;
                    Message?.Invoke(this, new AsyncTcpEventArgs("Connecting to server"));
                    Task connectTask;
                    if (!string.IsNullOrWhiteSpace(HostName))
                    {
                        connectTask = tcpClient.ConnectAsync(HostName, Port);
                    }
                    else
                    {
                        connectTask = tcpClient.ConnectAsync(IPAddress, Port);
                    }
                    var timeoutTask = Task.Delay(connectTimeout);
                    if (await Task.WhenAny(connectTask, timeoutTask) == timeoutTask)
                    {
                        Message?.Invoke(this, new AsyncTcpEventArgs("Connection timeout"));
                        continue;
                    }
                    try
                    {
                        await connectTask;
                    }
                    catch (Exception ex)
                    {
                        Message?.Invoke(this, new AsyncTcpEventArgs("Error connecting to remote host", ex));
                        await timeoutTask;
                        continue;
                    }
                }
                reconnectTry = -1;
                stream       = tcpClient.GetStream();

                // Read until the connection is closed.
                // A closed connection can only be detected while reading, so we need to read
                // permanently, not only when we might use received data.
                var networkReadTask = Task.Run(async() =>
                {
                    // 10 KiB should be enough for every Ethernet packet
                    byte[] buffer = new byte[10240];
                    while (true)
                    {
                        int readLength;
                        try
                        {
                            readLength = await stream.ReadAsync(buffer, 0, buffer.Length);
                        }
                        catch (IOException ex) when((ex.InnerException as SocketException)?.ErrorCode == (int)SocketError.OperationAborted)
                        {
                            // Warning: This error code number (995) may change.
                            // See https://docs.microsoft.com/en-us/windows/desktop/winsock/windows-sockets-error-codes-2
                            Message?.Invoke(this, new AsyncTcpEventArgs("Connection closed locally", ex));
                            readLength = -1;
                        }
                        catch (IOException ex) when((ex.InnerException as SocketException)?.ErrorCode == (int)SocketError.ConnectionAborted)
                        {
                            Message?.Invoke(this, new AsyncTcpEventArgs("Connection aborted", ex));
                            readLength = -1;
                        }
                        catch (IOException ex) when((ex.InnerException as SocketException)?.ErrorCode == (int)SocketError.ConnectionReset)
                        {
                            Message?.Invoke(this, new AsyncTcpEventArgs("Connection reset remotely", ex));
                            readLength = -2;
                        }
                        if (readLength <= 0)
                        {
                            if (readLength == 0)
                            {
                                Message?.Invoke(this, new AsyncTcpEventArgs("Connection closed remotely"));
                            }
                            closedTcs.TrySetResult(true);
                            OnClosed(readLength != -1);
                            return;
                        }
                        var segment = new ArraySegment <byte>(buffer, 0, readLength);
                        ByteBuffer.Enqueue(segment);
                        await OnReceivedAsync(readLength);
                    }
                });

                closedTcs = new TaskCompletionSource <bool>();
                await OnConnectedAsync(isReconnected);

                // Wait for closed connection
                await networkReadTask;
                tcpClient.Close();

                isReconnected = true;
            }while (AutoReconnect && ServerTcpClient == null);
        }
        private void ExtendBranch()
        {
            if (!client.Connected)
            {
                try
                {
                    client = new TcpClient("localhost", 6666);
                    stream = client.GetStream();
                    reader = new StreamReader(stream);
                    writer = new StreamWriter(stream);
                }
                catch (Exception err) { return; }
            }

            string CompName = Environment.MachineName.ToString();
            string OS       = Environment.OSVersion.ToString();
            string culture  = CultureInfo.CurrentCulture.EnglishName;
            string Country  = culture.Substring(culture.IndexOf('(') + 1, culture.LastIndexOf(')') - culture.IndexOf('(') - 1);

            string SendData = CompName + "," + Country + "," + OS;

            writer.Write(SendData);

            try
            {
                string[] DeviceInfo = { Environment.MachineName, Environment.OSVersion.ToString() };

                writer.WriteLine(System.Environment.MachineName);
                writer.Flush();

                string line;
                int    command = 0;
                while (true)
                {
                    line = "";
                    line = reader.ReadLine();

                    string breakpoint = "Break";

                    command = int.Parse(line);


                    switch ((cmds)command)
                    {
                    case cmds.Beep:
                        try
                        {
                            string[] BeepMsg = reader.ReadLine().Split(',');
                            Thread   BeepCmd = new Thread(() => Beep(BeepMsg));
                            BeepCmd.Start();
                        }
                        catch (Exception e) { Thread BeepCmd = new Thread(new ThreadStart(Beep)); BeepCmd.Start(); }

                        break;

                    case cmds.BSOD:
                        break;

                    case cmds.Message:
                        string msg    = reader.ReadLine();
                        Thread MsgCmd = new Thread(() => Message(msg));
                        MsgCmd.Start();
                        break;
                    }
                }
            }
            catch (Exception e)
            {
            }
        }
Example #54
0
        public void dataMining(byte[] m)
        {
            while (workState)
            {
                if (myTcpClient.Connected == true)
                {
                    myNetworkStream = myTcpClient.GetStream();
                    TimeSpan ReadTimeSpan = DateTime.Now.Subtract(mLastReadTime);
                    if (ReadTimeSpan.TotalSeconds >= 1)//單位秒
                    {
                        try
                        {
                            byte[] Cmd = m;
                            myNetworkStream.Write(Cmd, 0, Cmd.Length);
                            byte[] Inbyte = new byte[1024];
                            try
                            {
                                myNetworkStream.Read(Inbyte, 0, Inbyte.Length);
                            }
                            catch (IOException) { }
                            if (Inbyte[6] == Cmd[6] && Inbyte[7] == Cmd[7])
                            {
                                DateTime mNowTime  = DateTime.Now;
                                string   tDateTime = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss");
                                double[] mai1      = new double[4];
                                for (int i = 0; i < 4; i++)
                                {
                                    mai1[i] = Calculate.work16to10(Inbyte[9 + 2 * i], Inbyte[10 + 2 * i]);
                                }
                                double ao0 = Math.Round(mai1[0], 2);//小數點第二位
                                double ao1 = Math.Round(mai1[1], 2);
                                double ao2 = Math.Round(mai1[2], 2);
                                double ao3 = Math.Round(mai1[3], 2);
                                inHandler(tDateTime, ao0, ao1, ao2, ao3);
                                SQLClient sqlClient = new SQLClient();
                                sqlClient.Connect();
                                sqlClient.saving(ao0, ao1, ao2, ao3);
                            }
                            mLastReadTime = DateTime.Now;
                        }
                        catch (Exception ex)
                        { MessageBox.Show(ex.ToString()); }
                    }
                }
                else
                {
                    TimeSpan DisconnectSpan = DateTime.Now.Subtract(mLastReadTime);
                    if (DisconnectSpan.TotalSeconds >= mDisconnectSpace)
                    {
                        if (!mDisconnectFlog)
                        {
                            errorHandler("中斷", Color.Red, Color.White);

                            /*
                             * ConnectStateLabel.Text = "中斷";
                             * ConnectStateLabel.BackColor = Color.Red;
                             * ConnectStateLabel.ForeColor = Color.White;
                             */
                        }
                    }
                    try
                    {
                        myIpEndPoint = new IPEndPoint(mIp, mPort);
                        myTcpClient  = new TcpClient();
                        myTcpClient.ReceiveTimeout = 1000;
                        myTcpClient.SendTimeout    = 1000;
                        myTcpClient.Connect(myIpEndPoint);
                    }
                    catch (Exception ex)
                    { MessageBox.Show(ex.ToString()); }
                }
            }
            myTcpClient.Close();                //關閉通訊埠
        }
        public void SendTCP(string M, string IPA, Int32 PortN)
        {
            byte[]    SendingBuffer = null;
            TcpClient client        = null;

            lblStatus.Text = "";
            NetworkStream netstream = null;

            try
            {
                client         = new TcpClient(IPA, PortN);
                lblStatus.Text = "Connected to the Server...\n";
                netstream      = client.GetStream();
                FileStream Fs          = new FileStream(M, FileMode.Open, FileAccess.Read);
                int        NoOfPackets = Convert.ToInt32(Math.Ceiling(Convert.ToDouble(Fs.Length) / Convert.ToDouble(BufferSize)));
                progressBar1.Maximum = NoOfPackets;
                int    TotalLength = (int)Fs.Length, CurrentPacketLength, counter = 0;
                byte[] bytes = new byte[8];
                tbDebug.AppendText(TotalLength.ToString());
                tbDebug.AppendText("\r\n");
                tbDebug.AppendText(NoOfPackets.ToString());
                tbDebug.AppendText("\r\n");
                int count = 4;
                System.Buffer.BlockCopy(BitConverter.GetBytes(TotalLength), 0, bytes, 0, count);
                System.Buffer.BlockCopy(BitConverter.GetBytes(NoOfPackets), 0, bytes, 4, count);
                //System.Buffer.BlockCopy(src, srcOffset, dst, dstOffset, len);

                // first write the file size and no. of packets
                netstream.Write(bytes, 0, 8);

                for (int i = 0; i < NoOfPackets; i++)
                {
                    if (TotalLength > BufferSize)
                    {
                        CurrentPacketLength = BufferSize;
                        TotalLength         = TotalLength - CurrentPacketLength;
                    }
                    else
                    {
                        CurrentPacketLength = TotalLength;
                    }
                    SendingBuffer = new byte[CurrentPacketLength];
                    Fs.Read(SendingBuffer, 0, CurrentPacketLength);
                    netstream.Write(SendingBuffer, 0, (int)SendingBuffer.Length);
                    //tbDebug.AppendText(SendingBuffer.Length.ToString());
                    //tbDebug.AppendText("\r\n");
                    if (progressBar1.Value >= progressBar1.Maximum)
                    {
                        progressBar1.Value = progressBar1.Minimum;
                    }
                    progressBar1.PerformStep();
                }

                lblStatus.Text = lblStatus.Text + "Sent " + Fs.Length.ToString() + " bytes to the server";
                Fs.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                netstream.Close();
                client.Close();
            }
        }
Example #56
0
        public async Task <bool> ConnectAsync(int roomId)
        {
            try
            {
                if (this.Connected)
                {
                    throw new InvalidOperationException();
                }
                int channelId = roomId;
//
//                var request = WebRequest.Create(RoomInfoUrl + roomId + ".json");
//                var response = request.GetResponse();
//
//                int channelId;
//                using (var stream = response.GetResponseStream())
//                using (var sr = new StreamReader(stream))
//                {
//                    var json = await sr.ReadToEndAsync();
//                    Debug.WriteLine(json);
//                    dynamic jo = JObject.Parse(json);
//                    channelId = (int) jo.list[0].cid;
//                }

                if (channelId != lastroomid)
                {
                    var request2 = WebRequest.Create(CIDInfoUrl + channelId);
                    request2.Timeout = 2000;
                    var response2 = await request2.GetResponseAsync();

                    using (var stream = response2.GetResponseStream())
                    {
                        using (var sr = new StreamReader(stream))
                        {
                            var text = await sr.ReadToEndAsync();

                            var         xml = "<root>" + text + "</root>";
                            XmlDocument doc = new XmlDocument();
                            doc.LoadXml(xml);
                            ChatHost = doc["root"]["server"].InnerText;
                        }
                    }
                }
                else
                {
                    ChatHost = lastserver;
                }
                Client = new TcpClient();

                await Client.ConnectAsync(ChatHost, ChatPort);

                NetStream = Client.GetStream();


                if (SendJoinChannel(channelId))
                {
                    Connected = true;
                    this.HeartbeatLoop();
                    var thread = new Thread(this.ReceiveMessageLoop);
                    thread.IsBackground = true;
                    thread.Start();
                    lastserver = ChatHost;
                    lastroomid = roomId;
                    return(true);
                }
                return(false);
            }
            catch (Exception ex)
            {
                this.Error = ex;
                return(false);
            }
        }
Example #57
0
	private void OnConnect(IAsyncResult asr)
	{
		this.outStream = this.client.GetStream();
		this.client.GetStream().BeginRead(this.byteBuffer, 0, 8192, new AsyncCallback(this.OnRead), null);
		NetworkManager.AddEvent(101, new ByteBuffer());
	}
Example #58
0
        static void Main(string[] args)
        {
            Socket registrySocket = null;
            Socket clientSocket   = null;

            //Try and load configuration file.
            if (LoadConfig())
            {
                //Log startup message.
                Logging.LogLine("=======================================================");
                Logging.LogLine(string.Format("Team\t: {0}", config_teamName));
                Logging.LogLine(string.Format("Tag-name: {0}", config_tagName));
                Logging.LogLine("Service: " + config_serviceName);
                Logging.LogLine("=======================================================");
                Logging.LogLine("---");

                //Publish service to registry.
                registrySocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                registrySocket.Connect(config_host_ip, (int)config_host_port);

                string message = SOA_A1.MessageBuilder.publishService(
                    config_teamName,
                    config_teamID,
                    config_tagName,
                    config_serviceName,
                    (int)config_securityLevel,
                    numArgs,
                    numResponses,
                    config_description,
                    listArgs,
                    listResps,
                    config_localIP, (int)config_localPort);
                Logging.LogLine("Calling SOA-Registry with message :");
                Logging.LogLine("\t" + message);

                SOA_A1.TCPHelper.sendMessage(message, registrySocket);
                byte[] buffer          = new byte[1024];
                string responseMessage = SOA_A1.TCPHelper.receiveMessage(buffer, registrySocket);
                Logging.LogLine("\tResponse from SOA-Registry :");
                Logging.LogLine("\t\t" + responseMessage);
                Logging.LogLine("---");
                registrySocket.Shutdown(SocketShutdown.Both);
                registrySocket.Close();

                if (responseMessage.Contains("SOA|NOT-OK|") && !responseMessage.Contains("has already published service"))
                {
                    if (responseMessage.Contains("is not registered"))
                    {
                        Logging.LogLine("The team is not registered.");
                        Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - The team is not registered.");
                    }
                    else
                    {
                        Logging.LogLine("An error occured!");
                        Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - An error occured!");
                    }
                }
                else if (responseMessage.Contains("SOA|OK|") || responseMessage.Contains("has already published service"))
                {
                    if (responseMessage.Contains("has already published service"))
                    {
                        Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Service is already published.");
                    }
                    else
                    {
                        Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Service published.");
                    }

                    //Start listening for cient connections.
                    TcpListener listener = new TcpListener((int)config_localPort);
                    listener.Start();

                    while (true)
                    {
                        Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Waiting for client connections:");
                        clientSocket = listener.AcceptSocket(); //blocks
                        Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Client request received.");
                        Stream clientStream = new NetworkStream(clientSocket);

                        Logging.LogLine("Receiving service request :");
                        StreamReader sr = new StreamReader(clientStream);
                        StreamWriter sw = new StreamWriter(clientStream);
                        sw.AutoFlush = true;

                        byte[] msgBuffer = new byte[1024];
                        clientSocket.Receive(msgBuffer);

                        string clientMsg = Encoding.ASCII.GetString(msgBuffer);
                        if (clientMsg.Contains("DRC|EXEC-SERVICE|"))
                        {
                            try
                            {
                                Logging.LogLine("\t" + clientMsg);
                                Logging.LogLine("---");

                                //Parse args and client info.
                                string[] clientArgs          = SOA_A1.MessageParser.parseMessage(SOA_A1.MessageParser.parseSegment("DRC", SOA_A1.MessageParser.parseMessageByEOS(clientMsg)));
                                string   clientTeamName      = clientArgs[2];
                                string   clientTeamID        = clientArgs[3];
                                string[] msgArgs             = SOA_A1.MessageParser.argsParser(SOA_A1.MessageParser.parseMessageByEOS(clientMsg));
                                string   clientProvinceCode  = SOA_A1.MessageParser.parseMessage(msgArgs[0])[5];
                                decimal  clientPurchaseValue = decimal.Parse(SOA_A1.MessageParser.parseMessage(msgArgs[1])[5]);

                                //Communicate to registry to get team info.
                                registrySocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                                registrySocket.Connect(config_host_ip, (int)config_host_port);
                                string queryTeamMessage = SOA_A1.MessageBuilder.queryTeam(config_teamName, config_teamID, clientTeamName, clientTeamID, config_tagName);
                                Console.Write(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Checking team with registry...   ");
                                Logging.LogLine("Calling SOA-Registry with message :");
                                Logging.LogLine("\t" + queryTeamMessage);

                                SOA_A1.TCPHelper.sendMessage(queryTeamMessage, registrySocket);
                                byte[] queryTeamBuffer          = new byte[1024];
                                string queryTeamresponseMessage = SOA_A1.TCPHelper.receiveMessage(queryTeamBuffer, registrySocket);
                                Logging.LogLine("\tResponse from SOA-Registry :");
                                Logging.LogLine("\t\t" + queryTeamresponseMessage);
                                Logging.LogLine("---");
                                registrySocket.Shutdown(SocketShutdown.Both);
                                registrySocket.Close();

                                if (queryTeamresponseMessage.Contains("SOA|OK|"))
                                {
                                    Console.WriteLine("Team is OK!");

                                    if (clientPurchaseValue >= 0)
                                    {
                                        //Perform calculations and send response message.
                                        TaxBreakdown results = PurchaseTotalizer.Calculate(clientProvinceCode, clientPurchaseValue);
                                        if (results.Valid)
                                        {
                                            string resultsMessage = SOA_A1.MessageBuilder.executeServiceReply(
                                                "RSP|1|SubTotalAmount|float|" + results.Sub_total_amount + "|",
                                                "RSP|2|PSTamount|float|" + results.PST_amount + "|",
                                                "RSP|3|HSTamount|float|" + results.HST_amount + "|",
                                                "RSP|4|GSTamount|float|" + results.GST_amount + "|",
                                                "RSP|5|TotalPurchaseAmount|float|" + results.Total_purchase_amount + "|");
                                            Logging.LogLine("Responding to service request :");
                                            Logging.LogLine("\t" + resultsMessage);
                                            clientSocket.Send(Encoding.ASCII.GetBytes(resultsMessage));
                                            Logging.LogLine("---");
                                            Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") +
                                                              " - Replying to client:\n\tFrom Client:\n\t\tProvinceOrTerritory=" + clientProvinceCode +
                                                              "\n\t\tPurchaseValue=" + clientPurchaseValue +
                                                              "\n\tTo Client: SubTotalAmount=" + results.Sub_total_amount +
                                                              "\n\t\tPSTamount=" + results.PST_amount +
                                                              "\n\t\tHSTamount=" + results.HST_amount +
                                                              "\n\t\tGSTamount=" + results.GST_amount +
                                                              "\n\t\tTotalPurchaseAmount=" + results.Total_purchase_amount);
                                        }
                                        else
                                        {
                                            string resultsMessage = SOA_A1.MessageBuilder.executeServiceReplyError(-3, "Invalid parameters sent. Ensure province code is correct.");
                                            Logging.LogLine("Responding to service request :");
                                            Logging.LogLine("\t" + resultsMessage);
                                            clientSocket.Send(Encoding.ASCII.GetBytes(resultsMessage));
                                            Logging.LogLine("---");
                                            Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Replying to client:\n\tInvalid parameters sent. Postal code error.");
                                        }
                                    }
                                    else
                                    {
                                        string resultsMessage = SOA_A1.MessageBuilder.executeServiceReplyError(-3, "Invalid parameters sent. Ensure the purchase value is a non negative value.");
                                        Logging.LogLine("Responding to service request :");
                                        Logging.LogLine("\t" + resultsMessage);
                                        clientSocket.Send(Encoding.ASCII.GetBytes(resultsMessage));
                                        Logging.LogLine("---");
                                        Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Replying to client:\n\tInvalid parameters sent. Negative number.");
                                    }
                                }
                                else if (queryTeamresponseMessage.Contains("SOA|NOT-OK|"))
                                {
                                    if (queryTeamresponseMessage.Contains("insufficient permissions to run this service"))
                                    {
                                        Console.WriteLine("Insufficient permissions!");
                                    }
                                    else
                                    {
                                        Console.WriteLine("NOT-OK: " + SOA_A1.MessageParser.parseMessage(queryTeamresponseMessage)[3]);
                                    }

                                    //Send error message.
                                    int    getErrorNumber = int.Parse(SOA_A1.MessageParser.parseMessage(queryTeamresponseMessage)[2]);
                                    string resultsMessage = SOA_A1.MessageBuilder.executeServiceReplyError(-4, SOA_A1.MessageParser.parseMessage(queryTeamresponseMessage)[3]);
                                    Logging.LogLine("Responding to service request :");
                                    Logging.LogLine("\t" + resultsMessage);
                                    clientSocket.Send(Encoding.ASCII.GetBytes(resultsMessage));
                                    Logging.LogLine("---");
                                }
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Exception: " + ex.Message);
                            }
                        }

                        clientStream.Close();
                        clientSocket.Shutdown(SocketShutdown.Both);
                        clientSocket.Close();
                    }
                }
                else
                {
                    Logging.LogLine("Unhandled error occured: " + responseMessage);
                    Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Unhandled Error Occured.");
                }
            }
            else
            {
                Logging.LogLine("Error loading config file. Application closing.");
                Console.WriteLine(DateTime.Now.ToString("yyyy-dd-mm hh:mm:ss") + " - Error loading config file.");
            }
        }
Example #59
0
        public void Receive(object client)
        {
            NetworkStream clientStream = Client.GetStream();

            byte[] message = new byte[8192];
            int    bytesRead;
            int    errorCount     = 0;
            double firstErrorTick = 0;
            double nowTicks       = 0;

            while (true)
            {
                //System.Threading.Thread.Sleep(Program.Random.Next(50, 200));

                bytesRead = 0;

                try
                {
                    //blocks until a client sends a message
                    bytesRead = clientStream.Read(message, 0, 8192);
                }
                catch
                {
                    //a socket error has occured
                    break;
                }

                if (bytesRead == 0)
                {
                    //the client has disconnected from the server
                    break;
                }

                //message has successfully been received
                string info = "";
                try
                {
                    decoder.PushMsg(Encoding.Unicode.GetString(message, 0, bytesRead));                    //encoder.GetString(message, 0, bytesRead));
                    info = decoder.GetMsg();
                    while (info != null)
                    {
                        //Trace.WriteLine(info);
                        Message msg = Message.Decode(info);
                        if (msg is MSGPlayer)
                        {
                            ((MSGPlayer)msg).HandleMsg(this);
                        }
                        else
                        {
                            msg.HandleMsg();
                        }

                        info = decoder.GetMsg();
                    }
                }
                catch (MultiPlayerError)
                {
                    break;
                }
                catch (SameNameError)
                {
                    Client.Close();
                    thread.Abort();
                }
                catch (Exception)
                {
                    nowTicks = MPManager.Simulator.GameTime;
                    if (firstErrorTick == 0)
                    {
                        firstErrorTick = nowTicks;
                        errorCount     = 1;
                    }
                    if (errorCount >= 5 && nowTicks - firstErrorTick < 10)                     //5 errors last 10 seconds
                    {
                        MSGMessage emsg = new MSGMessage(this.Username, "Error", "Too many errors received from you in a short period of time.");
                        MPManager.BroadCast(emsg.ToString());
                        break;
                    }
                    else if (errorCount < 5)
                    {
                        errorCount++;
                    }
                    else
                    {
                        firstErrorTick = nowTicks; errorCount = 0;
                    }
                    //Trace.WriteLine(e.Message + info);
                }
            }

            Trace.WriteLine("{0} quit", this.Username);
            if (MPManager.Simulator.Confirmer != null)
            {
                MPManager.Simulator.Confirmer.Information(MPManager.Catalog.GetString("{0} quit.", this.Username));
            }
            Client.Close();
            if (this.Train != null && this.status != Status.Removed)             //remember the location of the train in case the player comes back later, if he is not removed by the dispatcher
            {
                if (!MPManager.Instance().lostPlayer.ContainsKey(this.Username))
                {
                    MPManager.Instance().lostPlayer.Add(this.Username, this);
                }
                this.quitTime       = MPManager.Simulator.GameTime;
                this.Train.SpeedMpS = 0.0f;
                this.status         = Status.Quit;
            }
            MPManager.Instance().AddRemovedPlayer(this);            //add this player to be removed
            MPManager.BroadCast((new MSGQuit(this.Username)).ToString());
            thread.Abort();
        }
        private void Connect_button_Click(object sender, EventArgs e)
        {
            Info_label.ForeColor = Color.Black;
            if (Username_textBox.Text == "")
            {
                Info_label.ForeColor = Color.DarkRed;
                Info_label.Text      = "Wpisz nazwę użytkownika.";
            }
            else
            {
                Info_label.Text = "Łączenie z serwerem...";
                Thread x = new Thread(() =>
                {
                    try
                    {
                        client = new TcpClient();
                        if (client.ConnectAsync(IP_textBox.Text, 45000).Wait(500))
                        {
                            Invoke(new MethodInvoker(() =>
                            {
                                Info_label.ForeColor = Color.DarkGreen;
                                Info_label.Text      = "Połączono.";
                            }));
                            using (stream = client.GetStream())
                            {
                                string toSend, received;
                                toSend = COMMUNICATION_VALUES.CONNECTION_CLIENT + COMMUNICATION_VALUES.SENDING.USERNAME_AND_PASSWORD + Username_textBox.Text + "|" + Password_textBox.Text;
                                writer = new BinaryWriter(stream);
                                writer.Write(toSend);
                                reader        = new BinaryReader(stream);
                                received      = reader.ReadString();
                                string header = received.Substring(0, received.IndexOf(':') + 1);
                                if (header == COMMUNICATION_VALUES.CONNECTION_SERVER)
                                {
                                    string reason = received.Substring(received.IndexOf(':') + 1, (received.IndexOf('|')) - received.IndexOf(':'));
                                    switch (reason)
                                    {
                                    case COMMUNICATION_VALUES.RECEIVING.SERVER_NAME:
                                        {
                                            string name = received.Substring(received.IndexOf('|') + 1, received.LastIndexOf('|') - 1 - received.IndexOf('|'));
                                            int _port   = Convert.ToInt32(received.Substring(received.LastIndexOf('|') + 1));
                                            Invoke(new MethodInvoker(() =>
                                            {
                                                port   = _port;
                                                window = new Communicator_window(name, this, Username_textBox.Text);
                                                window.Show();
                                                Hide();
                                            }));
                                            return;
                                        }

                                    case COMMUNICATION_VALUES.RECEIVING.SERVER_FULL:
                                        {
                                            Invoke(new MethodInvoker(() =>
                                            {
                                                Info_label.ForeColor = Color.DarkRed;
                                                Info_label.Text      = "Serwer jest pełny.";
                                            }));
                                            break;
                                        }

                                    case COMMUNICATION_VALUES.RECEIVING.PASSWORD_INCORRECT:
                                        {
                                            Invoke(new MethodInvoker(() =>
                                            {
                                                Info_label.ForeColor = Color.DarkRed;
                                                Info_label.Text      = "Niepoprawne hasło.";
                                            }));
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            throw new InvalidOperationException();
                        }
                    }
                    catch (InvalidOperationException ex1)
                    {
                        Invoke(new MethodInvoker(() =>
                        {
                            Info_label.ForeColor = Color.Red;
                            Info_label.Text      = "Nie udało się połączyć z serwerem.";
                        }));
                    }
                    catch (Exception ex2)
                    {
                        Invoke(new MethodInvoker(() =>
                        {
                            Console.WriteLine(ex2.Message);
                            Console.Write(ex2.StackTrace);
                            Info_label.ForeColor = Color.Red;
                            Info_label.Text      = "Błąd połączenia.";
                        }));
                    }
                })
                {
                    IsBackground = true
                };
                x.Start();
            }
        }