C# Telnet协议实现与源码解析

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

class TcpServer
{
    private TcpListener tcpListener;
    private int port = 13000;

    public TcpServer()
    {
        tcpListener = new TcpListener(IPAddress.Any, port);
    }

    public void Start()
    {
        tcpListener.Start();
        Console.WriteLine("Server started...");

        while (true)
        {
            TcpClient client = tcpListener.AcceptTcpClient();
            Thread clientThread = new Thread(new ParameterizedThreadStart(HandleClient));
            clientThread.Start(client);
        }
    }

    private void HandleClient(object obj)
    {
        TcpClient client = (TcpClient)obj;
        NetworkStream stream = client.GetStream();

        byte[] buffer = new byte[1024];
        int bytesRead;

        try
        {
            while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
            {
                string message = Encoding.ASCII.GetString(buffer, 0, bytesRead);
                Console.WriteLine("Received: " + message);

                // Echo back message to the sender
                byte[] data = Encoding.ASCII.GetBytes(message);
                stream.Write(data, 0, data.Length);
                Console.WriteLine("Sent: " + message);
            }
        }
        catch (Exception e)
        {
            Console.WriteLine("Exception: " + e.ToString());
        }
        finally
        {
            client.Close();
        }
    }
}

class Program
{
    static void Main()
    {
        TcpServer server = new TcpServer();
        server.Start();
    }
}

// 创建一个TCP的Socket实例
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

// 服务端的IP地址和端口信息
IPAddress serverIP = IPAddress.Parse("192.168.1.1");
int port = 12345;

// 连接到服务端
socket.Connect(new IPEndPoint(serverIP, port));

// 发送数据
string messageToSend = "Hello, Server!";
byte[] dataToSend = Encoding.UTF8.GetBytes(messageToSend);
socket.Send(dataToSend);

// 接收数据
byte[] buffer = new byte[1024];
int bytesReceived = socket.Receive(buffer);

// 关闭连接
socket.Shutdown(SocketShutdown.Both);
socket.Close();

// 异步发送数据
socket.BeginSend(dataToSend, 0, dataToSend.Length, SocketFlags.None, 
    new AsyncCallback(SendCallback), socket);

// 异步接收数据
socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, 
    new AsyncCallback(ReceiveCallback), socket);

// 异步发送回调函数
void SendCallback(IAsyncResult ar)
{
    Socket handler = (Socket)ar.AsyncState;
    int bytesSent = handler.EndSend(ar);
    Console.WriteLine($"Sent {bytesSent} bytes to server.");
}

// 异步接收回调函数
void ReceiveCallback(IAsyncResult ar)
{
    Socket handler = (Socket)ar.AsyncState;
    int bytesRead = handler.EndReceive(ar);
    if (bytesRead > 0)
    {
        string response = Encoding.UTF8.GetString(buffer, 0, bytesRead);
        Console.WriteLine($"Received {bytesRead} bytes from server: {response}");
    }
}

// 设置Socket选项 - 保活间隔
int keepAliveTime = 300000; // 单位毫秒
int keepAliveInterval = 10000; // 单位毫秒
int keepAliveRetryCount = 5; // 重试次数

socket.IOControl(IOControlCode.KeepAliveValues, BitConverter.GetBytes(keepAliveTime), null);
socket.IOControl(IOControlCode.KeepAliveIntervals, BitConverter.GetBytes(keepAliveInterval), null);

// 创建一个TCP Socket实例
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

// 连接到远程服务器
IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Parse("192.168.1.100"), 11000);
socket.Connect(remoteEndPoint);

// 发送数据
byte[] dataToSend = Encoding.UTF8.GetBytes("Hello, Server!");
socket.Send(dataToSend);

// 接收数据
byte[] buffer = new byte[1024];
int bytesReceived = socket.Receive(buffer);

// 输出接收到的数据
Console.WriteLine(Encoding.UTF8.GetString(buffer, 0, bytesReceived));

// 关闭Socket连接
socket.Shutdown(SocketShutdown.Both);
socket.Close();

graph LR
A[开始] --> B{创建Socket}
B --> C[指定服务端信息]
C --> D{连接服务端}
D -- 成功 --> E[发送数据]
D -- 失败 --> F[处理异常]
E --> G[接收数据]
G --> H{是否关闭连接}
H -- 是 --> I[关闭Socket]
H -- 否 --> J[继续通信]
I --> K[结束]
J --> E

// Server端代码示例
TcpListener listener = new TcpListener(IPAddress.Any, port);
listener.Start();
TcpClient client = listener.AcceptTcpClient();
NetworkStream stream = client.GetStream();

StreamReader reader = new StreamReader(stream);
StreamWriter writer = new StreamWriter(stream) { AutoFlush = true };

// 循环接收客户端发送的命令
while (true)
{
    string command = reader.ReadLine();
    if (command == null) break;

    // 执行命令并返回结果
    string response = ExecuteCommand(command);
    writer.WriteLine(response);
}

// 关闭连接
client.Close();
listener.Stop();

private void ParseCommandLine(string input)
{
    string[] parts = input.Split(' ');

    string command = parts[0];
    string[] args = parts.Skip(1).ToArray();

    // 根据命令名执行不同的处理逻辑
    switch (command)
    {
        case "help":
            HelpCommand(args);
            break;
        case "exit":
            ExitCommand();
            break;
        // 更多的命令可以在这里继续添加
    }
}

private void HelpCommand(string[] args)
{
    // 显示帮助信息
}

private void ExitCommand()
{
    // 关闭程序
}

// 命令与处理方法的映射
Dictionary<string, Action<string[]>> commandMap = new Dictionary<string, Action<string[]>>()
{
    ["help"] = HelpCommand,
    ["exit"] = ExitCommand,
    // 添加其他命令映射
};

private void ExecuteMappedCommand(string command, string[] args)
{
    if (commandMap.TryGetValue(command, out var action))
    {
        action(args);
    }
    else
    {
        // 未找到命令的处理逻辑
    }
}

static void Main(string[] args)
{
    Console.Write("Welcome to the Telnet Server Command Line Interface. Type 'help' for a list of commands.\n> ");
    while (true)
    {
        string input = Console.ReadLine();
        ParseCommandLine(input);
    }
}

private static void ParseCommandLine(string input)
{
    // ... 同上节代码 ...
}

// 示例代码
using System;
using System.IO;
using System.Net.Sockets;

public class TelnetDataSender
{
    public static void SendData(Socket socket, string data)
    {
        // 将数据转换为NVT格式
        data = ConvertToNVTFormat(data);
        // 发送数据长度信息
        byte[] dataLengthBytes = BitConverter.GetBytes(data.Length);
        socket.Send(dataLengthBytes, dataLengthBytes.Length, SocketFlags.None);
        // 发送数据
        byte[] dataBytes = Encoding.ASCII.GetBytes(data);
        socket.Send(dataBytes, dataBytes.Length, SocketFlags.None);
    }

    private static string ConvertToNVTFormat(string data)
    {
        // 这里应实现将数据转换为NVT格式的逻辑
        // 示例中仅为示意，实际转换方式取决于Telnet协议规范
        return data.Replace("\r\n", "\r\nIAC EOL\r\n");
    }
}

// 示例代码
using System;
using System.IO;
using System.Net.Sockets;

public class TelnetDataReceiver
{
    public static string ReceiveData(Socket socket)
    {
        // 接收数据长度信息
        byte[] dataLengthBytes = new byte[2];
        int receivedBytes = socket.Receive(dataLengthBytes, dataLengthBytes.Length, SocketFlags.None);
        int dataLength = BitConverter.ToInt16(dataLengthBytes, 0);
        // 接收数据
        byte[] dataBytes = new byte[dataLength];
        socket.Receive(dataBytes, dataBytes.Length, SocketFlags.None);
        // 数据还原
        string data = ConvertFromNVTFormat(Encoding.ASCII.GetString(dataBytes));
        return data;
    }

    private static string ConvertFromNVTFormat(string data)
    {
        // 这里应实现从NVT格式还原为原始数据的逻辑
        // 示例中仅为示意
        return data.Replace("\r\nIAC EOL\r\n", "\r\n");
    }
}

// 示例代码：使用ZLIB进行数据压缩和解压缩
using System.IO.Compression;
using System.Text;

public class DataCompression
{
    public static byte[] CompressData(string data)
    {
        byte[] dataBytes = Encoding.UTF8.GetBytes(data);
        using (MemoryStream output = new MemoryStream())
        {
            using (DeflateStream gzip = new DeflateStream(output, CompressionMode.Compress))
            {
                gzip.Write(dataBytes, 0, dataBytes.Length);
            }
            return output.ToArray();
        }
    }

    public static string DecompressData(byte[] dataBytes)
    {
        using (MemoryStream input = new MemoryStream(dataBytes))
        {
            using (DeflateStream gzip = new DeflateStream(input, CompressionMode.Decompress))
            {
                using (StreamReader reader = new StreamReader(gzip, Encoding.UTF8))
                {
                    return reader.ReadToEnd();
                }
            }
        }
    }
}

// 示例代码：异常处理
try
{
    string data = ReceiveData(socket);
    // 处理接收到的数据
    HandleReceivedData(data);
}
catch (SocketException ex)
{
    Console.WriteLine($"网络异常: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"未知错误: {ex.Message}");
}

// 处理接收到的数据的方法
private static void HandleReceivedData(string data)
{
    // 根据数据类型和内容执行相应的处理逻辑
}

try
{
    // 尝试执行的代码
}
catch (Exception ex)
{
    // 异常处理代码
}
finally
{
    // 清理代码，无论是否发生异常都会执行
}

try
{
    TcpClient client = new TcpClient(host, port);
}
catch (SocketException ex)
{
    Console.WriteLine($"无法连接到 {host}:{port}。请检查网络设置和服务器状态。");
}

TcpClient client = new TcpClient();
client.Connect(host, port);

client.NoDelay = true; // 关闭Nagle算法，减少延迟

// 监听连接关闭事件
client.ConnectionClosed += (sender, args) =>
{
    Console.WriteLine("连接已断开。");
};

// ...执行远程命令交互...

// 断开连接前确保执行清理操作
client.Close();

public void ConnectToRemoteHost(string host, int port)
{
    try
    {
        using(TcpClient client = new TcpClient())
        {
            client.NoDelay = true;
            client.Connect(host, port);
            // 进行远程交互...
        }
    }
    catch (SocketException ex)
    {
        // 处理连接异常...
    }
}