连接到telnet服务器并发送/接收数据

Question

So I am trying to connect to my telnet server, which works. It recives the first lot of data from the server which is us being asked to enter password to connect. But when I type in the password it does nothing and nothing that is recieved is printed to my console.

An example of the output is as follows:

Connected to server.
Please enter password:
Response: MYPASSHERE
__BLANK RESPONSE FROM SERVER__
Response:

I am currently using this code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Threading;

namespace _7DaysServerManager
{
    public class ServerSocket
    {
        private TcpClient client;
        private Thread readWriteThread;
        private NetworkStream networkStream;
        private string password;

        public ServerSocket(string ip, int port)
        {
            try
            {
                client = new TcpClient(ip, port);
                Console.WriteLine("Connected to server.");
            } 
            catch (SocketException)
            {
                Console.WriteLine("Failed to connect to server");
                return;
            }

            //Assign networkstream
            networkStream = client.GetStream();

            //start socket read/write thread
            readWriteThread = new Thread(readWrite);
            readWriteThread.Start();
        }

        private void readWrite()
        {
            string command, recieved;

            //Read first thing givent o us
            recieved = read();
            Console.WriteLine(recieved);

            //Set up connection loop
            while (true) 
            {
                Console.Write("Response: ");
                command = Console.ReadLine();

                if (command == "exit")
                    break;

                write(command);
                recieved = read();

                Console.WriteLine(recieved);
            }

            Console.WriteLine("Disconnected from server");
            networkStream.Close();
            client.Close();
        }

        public void write(string message)
        {
            networkStream.Write(Encoding.ASCII.GetBytes(message), 0, message.Length);
            networkStream.Flush();
        }

        public string read()
        {
            byte[] data = new byte[1024];
            string recieved = "";

            int size = networkStream.Read(data, 0, data.Length);
            recieved = Encoding.ASCII.GetString(data, 0, size);

            return recieved;
        }
    }
}

Answer 1

I believe you need your code to look more like this:

message += Environment.NewLine;
byte[] messageBytes = Encoding.ASCII.GetBytes(message);
networkStream.Write(messageBytes, 0, messageBytes.Length);

Ie if you don't terminate the password with a newline character, the server doesn't know you're done entering the password (TCP is not message-oriented, so the fact that you didn't continue sending bytes in no way provides any indication that you're done sending the password).

Note also that you should use the actual length of the byte[] returned from GetBytes() as the length of the data. For ASCII, it's true you can compute the number of bytes trivially from the message length, but using the actual byte count is a good habit to get into. You may not always be dealing with ASCII in networking code.

Finally, I will suggest that you change your code in a couple of ways:

1. Wrap the NetworkStream in StreamReader and StreamWriter instances, to make sending and receiving text easier (don't forget to set the encoding to Encoding.ASCII for the reader and writer).
2. Read and write in different threads. Or even better, use StreamReader.ReadLineAsync() so that the reading is done asynchronously without an explicit thread.

If you don't switch to StreamReader , you should still read (asynchronously or not) in a different thread, and don't forget that you need to keep reading from the buffer all the time, as a response from the server may or may not be received in a single call to Read() .