C#使用TcpClient实现telnet功能

1. using System; 
2. using System.Collections.Generic; 
3. using System.Text; 
4. using System.Net.Sockets; 
5.  
6. namespace testTelnet 
7. { 
8.     enum Verbs 
9.     { 
10.         WILL = 251, 
11.         WONT = 252, 
12.         DO = 253, 
13.         DONT = 254, 
14.         IAC = 255 
15.     } 
16.  
17.     enum Options 
18.     { 
19.         SGA = 3 
20.     } 
21.  
22.     class TelnetConnection 
23.     { 
24.         TcpClient tcpSocket; 
25.  
26.         int TimeOutMs = 1*1000; 
27.  
28.         public TelnetConnection(String Hostname, int Port) 
29.         { 
30.             tcpSocket = new TcpClient(Hostname, Port); 
31.              
32.         } 
33.  
34.         public string Login(string Username, string Password, int LoginTimeOutMs) 
35.         { 
36.             int oldTimeOutMs = TimeOutMs; 
37.             TimeOutMs = LoginTimeOutMs; 
38.             string s = Read(); 
39.             if (!s.TrimEnd().EndsWith(":")) 
40.                 throw new Exception("Failed to connect : no login prompt"); 
41.             WriteLine(Username); 
42.  
43.             s += Read(); 
44.             if (!s.TrimEnd().EndsWith(":")) 
45.                 throw new Exception("Failed to connect : no password prompt"); 
46.             WriteLine(Password); 
47.  
48.             s += Read(); 
49.             TimeOutMs = oldTimeOutMs; 
50.              
51.             return s; 
52.         } 
53.  
54.         public void DisConnect() 
55.         { 
56.             if (tcpSocket != null) 
57.             { 
58.                 if (tcpSocket.Connected) 
59.                 { 
60.                     tcpSocket.Client.Disconnect(true); 
61.                 } 
62.             } 
63.         } 
64.  
65.         public void WriteLine(string cmd) 
66.         { 
67.             Write(cmd + "\r\n"); 
68.         } 
69.  
70.         public void Write(string cmd) 
71.         { 
72.             if (!tcpSocket.Connected) return; 
73.  
74.             byte[] buf = System.Text.ASCIIEncoding.ASCII.GetBytes(cmd.Replace("\0xFF", "\0xFF\0xFF")); 
75.             tcpSocket.GetStream().Write(buf, 0, buf.Length); 
76.         } 
77.  
78.         public string Read() 
79.         { 
80.             if (!tcpSocket.Connected) return null; 
81.             StringBuilder sb = new StringBuilder(); 
82.             do 
83.             { 
84.                 ParseTelnet(sb); 
85.                 System.Threading.Thread.Sleep(TimeOutMs); 
86.             } while (tcpSocket.Available > 0); 
87.  
88.             return ConvertToGB2312(sb.ToString()); 
89.         } 
90.  
91.         public bool IsConnected 
92.         { 
93.             get { return tcpSocket.Connected; } 
94.         } 
95.  
96.         void ParseTelnet(StringBuilder sb) 
97.         { 
98.             while (tcpSocket.Available > 0) 
99.             { 
100.                 int input = tcpSocket.GetStream().ReadByte(); 
101.                 switch (input) 
102.                 { 
103.                     case -1: 
104.                         break; 
105.                     case (int)Verbs.IAC: 
106.                         // interpret as command 
107.                         int inputverb = tcpSocket.GetStream().ReadByte(); 
108.                         if (inputverb == -1) break; 
109.                         switch (inputverb) 
110.                         { 
111.                             case (int)Verbs.IAC: 
112.                                 //literal IAC = 255 escaped, so append char 255 to string 
113.                                 sb.Append(inputverb); 
114.                                 break; 
115.                             case (int)Verbs.DO: 
116.                             case (int)Verbs.DONT: 
117.                             case (int)Verbs.WILL: 
118.                             case (int)Verbs.WONT: 
119.                                 // reply to all commands with "WONT", unless it is SGA (suppres go ahead) 
120.                                 int inputoption = tcpSocket.GetStream().ReadByte(); 
121.                                 if (inputoption == -1) break; 
122.                                 tcpSocket.GetStream().WriteByte((byte)Verbs.IAC); 
123.                                 if (inputoption == (int)Options.SGA) 
124.                                     tcpSocket.GetStream().WriteByte(inputverb == (int)Verbs.DO ? (byte)Verbs.WILL : (byte)Verbs.DO); 
125.                                 else 
126.                                     tcpSocket.GetStream().WriteByte(inputverb == (int)Verbs.DO ? (byte)Verbs.WONT : (byte)Verbs.DONT); 
127.                                 tcpSocket.GetStream().WriteByte((byte)inputoption); 
128.                                 break; 
129.                             default: 
130.                                 break; 
131.                         } 
132.                         break; 
133.                     default: 
134.                         sb.Append((char)input); 
135.                         break; 
136.                 } 
137.             } 
138.         } 
139.  
140.         private string ConvertToGB2312(string str_origin) 
141.         { 
142.             char[] chars = str_origin.ToCharArray(); 
143.             byte[] bytes = new byte[chars.Length]; 
144.             for (int i = 0; i < chars.Length; i++) 
145.             { 
146.                 int c = (int)chars[i]; 
147.                 bytes[i] = (byte)c; 
148.             } 
149.             Encoding Encoding_GB2312 = Encoding.GetEncoding("GB2312"); 
150.             string str_converted = Encoding_GB2312.GetString(bytes); 
151.             return str_converted; 
152.         } 
153.     } 
154. } 

// minimalistic telnet implementation
// conceived by Tom Janssens on 2007/06/06  for codeproject
//
// http://www.corebvba.be



using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;

namespace testTelnet
{
    enum Verbs
    {
        WILL = 251,
        WONT = 252,
        DO = 253,
        DONT = 254,
        IAC = 255
    }

    enum Options
    {
        SGA = 3
    }

    class TelnetConnection
    {
        TcpClient tcpSocket;

        int TimeOutMs = 1*1000;

        public TelnetConnection(String Hostname, int Port)
        {
            tcpSocket = new TcpClient(Hostname, Port);
            
        }

        public string Login(string Username, string Password, int LoginTimeOutMs)
        {
            int oldTimeOutMs = TimeOutMs;
            TimeOutMs = LoginTimeOutMs;
            string s = Read();
            if (!s.TrimEnd().EndsWith(":"))
                throw new Exception("Failed to connect : no login prompt");
            WriteLine(Username);

            s += Read();
            if (!s.TrimEnd().EndsWith(":"))
                throw new Exception("Failed to connect : no password prompt");
            WriteLine(Password);

            s += Read();
            TimeOutMs = oldTimeOutMs;
            
            return s;
        }

        public void DisConnect()
        {
            if (tcpSocket != null)
            {
                if (tcpSocket.Connected)
                {
                    tcpSocket.Client.Disconnect(true);
                }
            }
        }

        public void WriteLine(string cmd)
        {
            Write(cmd + "\r\n");
        }

        public void Write(string cmd)
        {
            if (!tcpSocket.Connected) return;

            byte[] buf = System.Text.ASCIIEncoding.ASCII.GetBytes(cmd.Replace("\0xFF", "\0xFF\0xFF"));
            tcpSocket.GetStream().Write(buf, 0, buf.Length);
        }

        public string Read()
        {
            if (!tcpSocket.Connected) return null;
            StringBuilder sb = new StringBuilder();
            do
            {
                ParseTelnet(sb);
                System.Threading.Thread.Sleep(TimeOutMs);
            } while (tcpSocket.Available > 0);

            return ConvertToGB2312(sb.ToString());
        }

        public bool IsConnected
        {
            get { return tcpSocket.Connected; }
        }

        void ParseTelnet(StringBuilder sb)
        {
            while (tcpSocket.Available > 0)
            {
                int input = tcpSocket.GetStream().ReadByte();
                switch (input)
                {
                    case -1:
                        break;
                    case (int)Verbs.IAC:
                        // interpret as command
                        int inputverb = tcpSocket.GetStream().ReadByte();
                        if (inputverb == -1) break;
                        switch (inputverb)
                        {
                            case (int)Verbs.IAC:
                                //literal IAC = 255 escaped, so append char 255 to string
                                sb.Append(inputverb);
                                break;
                            case (int)Verbs.DO:
                            case (int)Verbs.DONT:
                            case (int)Verbs.WILL:
                            case (int)Verbs.WONT:
                                // reply to all commands with "WONT", unless it is SGA (suppres go ahead)
                                int inputoption = tcpSocket.GetStream().ReadByte();
                                if (inputoption == -1) break;
                                tcpSocket.GetStream().WriteByte((byte)Verbs.IAC);
                                if (inputoption == (int)Options.SGA)
                                    tcpSocket.GetStream().WriteByte(inputverb == (int)Verbs.DO ? (byte)Verbs.WILL : (byte)Verbs.DO);
                                else
                                    tcpSocket.GetStream().WriteByte(inputverb == (int)Verbs.DO ? (byte)Verbs.WONT : (byte)Verbs.DONT);
                                tcpSocket.GetStream().WriteByte((byte)inputoption);
                                break;
                            default:
                                break;
                        }
                        break;
                    default:
                        sb.Append((char)input);
                        break;
                }
            }
        }

        private string ConvertToGB2312(string str_origin)
        {
            char[] chars = str_origin.ToCharArray();
            byte[] bytes = new byte[chars.Length];
            for (int i = 0; i < chars.Length; i++)
            {
                int c = (int)chars[i];
                bytes[i] = (byte)c;
            }
            Encoding Encoding_GB2312 = Encoding.GetEncoding("GB2312");
            string str_converted = Encoding_GB2312.GetString(bytes);
            return str_converted;
        }
    }
}

启动代码

[csharp] view plain copy print ?

1. static void Main(string[] args) 
2.         { 
3.             //create a new telnet connection to hostname "gobelijn" on port "23" 
4.             TelnetConnection tc = new TelnetConnection("127.0.0.1", 23); 
5.  
6.             //login with user "root",password "rootpassword", using a timeout of 100ms,  
7.             //and show server output 
8.             string s = tc.Login("administrator", "pw", 100); 
9.             Console.Write(s); 
10.  
11.             // server output should end with "{1}quot; or ">", otherwise the connection failed 
12.             string prompt = s.TrimEnd(); 
13.             prompt = s.Substring(prompt.Length - 1, 1); 
14.             if (prompt != ":") 
15.                 throw new Exception("Connection failed"); 
16.  
17.             prompt = ""; 
18.  
19.             // while connected 
20.             while (tc.IsConnected && prompt.Trim() != "exit") 
21.             { 
22.                 // display server output 
23.                 Console.Write(tc.Read()); 
24.  
25.                 // send client input to server 
26.                 prompt = Console.ReadLine(); 
27.                 tc.WriteLine(prompt); 
28.  
29.                 // display server output 
30.                 Console.Write(tc.Read()); 
31.             } 
32.  
33.             Console.WriteLine("***DISCONNECTED"); 
34.             Console.ReadLine(); 
35.  
36.         }