开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
TerminalConnection.cs
资源名称：Terminal_Control_jan_2009.zip　[点击查看]
上传用户：szltgg
上传日期：2019-05-16
资源大小：604k
文件大小：37k
源码类别：

Telnet服务器

开发平台：

C#

TerminalConnection.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: TerminalConnection.cs,v 1.2 2005/04/20 08:45:47 okajima Exp $
  4. */
  5. using System;
  6. using System.Diagnostics;
  7. using System.Net.Sockets;
  8. using System.Net;
  9. using System.Text;
  10. using System.Threading;
  11. using System.Windows.Forms;
  12. using System.IO;
  14. using Poderosa.ConnectionParam;
  15. using Poderosa.Connection;
  16. using Poderosa.Log;
  17. using Poderosa.SSH;
  18. using Poderosa.Toolkit;
  19. using Poderosa.Terminal;
  20. using Poderosa.Text;
  22. using Granados.SSHC;
  24. namespace Poderosa.Communication
  25. {
  26. public interface IDataReceiver {
  27. void DataArrived(byte[] buf, int offset, int count);
  28. void DisconnectedFromServer();
  29. void ErrorOccurred(string msg);
  30. }
  31. internal abstract class AbstractGuevaraSocket {
  33. protected IDataReceiver _callback;
  35. internal abstract void Transmit(byte[] data, int offset, int length);
  36. internal abstract void Flush();
  37. internal abstract void Close();
  38. internal abstract bool DataAvailable { get; }
  39. internal abstract void RepeatAsyncRead(IDataReceiver receiver);
  40. }
  41. internal class PlainGuevaraSocket : AbstractGuevaraSocket {
  42. private Socket _socket;
  43. private byte[] _buf;
  44. internal PlainGuevaraSocket(Socket s) {
  45. _socket = s;
  46. _buf = new byte[0x1000];
  47. }
  48. internal override bool DataAvailable {
  49. get {
  50. return _socket.Available>0;
  51. }
  52. }
  54. internal override void Transmit(byte[] data, int offset, int length) {
  55. _socket.Send(data, offset, length, SocketFlags.None);
  56. }
  57. internal override void Flush() {
  58. }
  59. internal override void Close() {
  60. _socket.Close();
  61. }
  62. internal override void RepeatAsyncRead(IDataReceiver receiver) {
  63. _callback = receiver;
  64. _socket.BeginReceive(_buf, 0, _buf.Length, SocketFlags.None, new AsyncCallback(RepeatCallback), null);
  65. }
  67. #if true
  68. private void RepeatCallback(IAsyncResult result) {
  69. try {
  70. int n = _socket.EndReceive(result);
  71. //GUtil.WriteDebugLog(String.Format("t={0}, n={1} av={2}", DateTime.Now.ToString(), n, _socket.Available));
  72. //Debug.WriteLine(String.Format("r={0}, n={1} ", result.IsCompleted, n));
  74. if(n > 0) {
  75. _callback.DataArrived(_buf, 0, n);
  76. _socket.BeginReceive(_buf, 0, _buf.Length, SocketFlags.None, new AsyncCallback(RepeatCallback), null);
  77. }
  78. else if(n < 0) {
  79. //WindowsME偵偍偄偰偼丄偲偒偳偒偙偙偱-1偑曉偭偰偒偰偄傞偙偲偑敪妎偟偨丅
  80. _socket.BeginReceive(_buf, 0, _buf.Length, SocketFlags.None, new AsyncCallback(RepeatCallback), null);
  81. }
  82. else
  83. _callback.DisconnectedFromServer();
  84. }
  85. catch(Exception ex) {
  86. if((ex is SocketException) && ((SocketException)ex).ErrorCode==995) {
  87. //GUtil.WriteDebugLog(String.Format("t={0} error995", DateTime.Now.ToString()));
  88. _socket.BeginReceive(_buf, 0, _buf.Length, SocketFlags.None, new AsyncCallback(RepeatCallback), null);
  89. }
  90. else
  91. _callback.ErrorOccurred(ex.Message);
  92. }
  93. }
  94. #else //庴怣捈屻偐傜儊僀儞僗儗僢僪偵張棟傪堏偡僶乕僕儑儞
  95. private int _readLen;
  96. private bool _nextReadRequired;
  97. private void RepeatCallback(IAsyncResult result) {
  98. _readLen = _socket.EndReceive(result);
  99. _nextReadRequired = false;
  100. GEnv.Frame.AsForm().Invoke(new MethodInvoker(ReadBody), null);
  101. if(_nextReadRequired)
  102. _socket.BeginReceive(_buf, 0, _buf.Length, SocketFlags.None, new AsyncCallback(RepeatCallback), null);
  103. }
  104. private void ReadBody() {
  105. try {
  106. Debug.Assert(!GEnv.Frame.AsForm().InvokeRequired);
  107. if(_readLen > 0) {
  108. _callback.DataArrived(_buf, 0, _readLen);
  109. _nextReadRequired = true;
  110. }
  111. else if(_readLen < 0) {
  112. //WindowsME偵偍偄偰偼丄偲偒偳偒偙偙偱-1偑曉偭偰偒偰偄傞偙偲偑敪妎偟偨丅
  113. //_socket.BeginReceive(_buf, 0, _buf.Length, SocketFlags.None, new AsyncCallback(RepeatCallback), null);
  114. _nextReadRequired = true;
  115. }
  116. else
  117. _callback.DisconnectedFromServer();
  118. }
  119. catch(Exception ex) {
  120. if((ex is SocketException) && ((SocketException)ex).ErrorCode==995) {
  121. //GUtil.WriteDebugLog(String.Format("t={0} error995", DateTime.Now.ToString()));
  122. _nextReadRequired = true;
  123. }
  124. else
  125. _callback.ErrorOccurred(ex.Message);
  126. }
  127. }
  128. #endif
  129. }
  130. internal class ChannelGuevaraSocket : AbstractGuevaraSocket, ISSHConnectionEventReceiver, ISSHChannelEventReceiver {
  131. private SSHChannel _channel;
  132. private bool _ready;
  133. private AutoResetEvent _event;
  135. internal ChannelGuevaraSocket() {
  136. _ready = false;
  137. }
  138. internal SSHChannel SSHChennal {
  139. get {
  140. return _channel;
  141. }
  142. set {
  143. _channel = value;
  144. }
  145. }
  147. internal override void RepeatAsyncRead(IDataReceiver cb) {
  148. Debug.Assert(_callback==null); //侾夞偟偐屇傫偱偼偩傔
  149. _callback = cb;
  150. if(_event!=null) {
  151. _event.Set();
  152. _event.Close();
  153. _event = null;
  154. }
  155. }
  157. internal override bool DataAvailable {
  158. get {
  159. return _channel.Connection.Available;
  160. }
  161. }
  162. internal override void Transmit(byte[] data, int offset, int length) {
  163. if(!_ready || _channel==null) throw new IOException("channel not ready");
  164. _channel.Transmit(data, offset, length);
  165. }
  166. internal override void Flush() {
  167. }
  168. internal override void Close() {
  169. _channel.Close();
  170. if(_channel.Connection.ChannelCount<=1)
  171. _channel.Connection.Close();
  172. }
  174. public void OnData(byte[] data, int offset, int length) {
  175. EnsureHandler();
  176. _callback.DataArrived(data, offset, length);
  177. }
  179. public void OnChannelEOF() {
  180. EnsureHandler();
  181. _callback.DisconnectedFromServer();
  182. }
  184. public void OnChannelError(Exception ex, string msg) {
  185. EnsureHandler();
  186. if(!_ready)
  187. msg = GEnv.Strings.GetString("Message.ChannelPoderosaSocket.FailedToPortforward") + msg;
  188. _callback.ErrorOccurred(msg);
  189. }
  191. public void OnChannelClosed() {
  192. EnsureHandler();
  193. _callback.DisconnectedFromServer();
  194. }
  196. public void OnChannelReady() {
  197. _ready = true;
  198. }
  200. public void OnAuthenticationPrompt(string[] msg) {
  201. for(int i=0; i<msg.Length; i++) {
  202. if(i==0) msg[i] += "rn";
  203. byte[] buf = Encoding.ASCII.GetBytes(msg[i]);
  204. OnData(buf, 0, buf.Length);
  205. }
  206. }
  208. public void OnExtendedData(int type, byte[] data) {
  209. }
  211. public void OnConnectionClosed() {
  212. EnsureHandler();
  213. _callback.DisconnectedFromServer();
  214. }
  215. public void OnDebugMessage(bool display, byte[] data) {
  216. Debug.WriteLine(String.Format("SSH debug {0}[{1}]", data.Length, data[0] ));
  217. }
  218. public void OnIgnoreMessage(byte[] data) {
  219. Debug.WriteLine(String.Format("SSH ignore {0}[{1}]", data.Length, data[0] ));
  220. }
  221. public void OnUnknownMessage(byte type, byte[] data) {
  222. Debug.WriteLine(String.Format("Unexpected SSH packet type {0}", type));
  223. }
  224. public void OnError(Exception ex, string msg) {
  225. EnsureHandler();
  226. _callback.ErrorOccurred(msg);
  227. }
  228. public void OnMiscPacket(byte type, byte[] data, int offset, int length) {
  229. }
  231. public Granados.SSHC.PortForwardingCheckResult CheckPortForwardingRequest(string host, int port, string originator, int originator_port) {
  232. return new Granados.SSHC.PortForwardingCheckResult();
  233. }
  234. public void EstablishPortforwarding(ISSHChannelEventReceiver receiver, SSHChannel channel) {
  235. }
  237. private void EnsureHandler() {
  238. if(_callback!=null) return;
  239. _event = new AutoResetEvent(false);
  240. _event.WaitOne();
  241. }
  242. }
  243. public abstract class TerminalConnection {
  245. internal TerminalParam _param;
  246. internal ITerminalTextLogger _loggerT;
  247. internal ITerminalBinaryLogger _loggerB;
  249. internal int _width;
  250. internal int _height;
  252. internal LogType _logType;
  253. internal string _logPath;
  254. //儘僌偺堦帪揑側僆僼偺偨傔偺僗僀僢僠
  255. internal bool _logsuspended;
  257. //憲庴怣偟偨僨乕僞僒僀僘偺忣曬
  258. internal int _sentPacketCount;
  259. internal int _sentDataSize;
  260. internal int _receivedPacketCount;
  261. internal int _receivedDataSize;
  263. internal IPAddress _serverAddress;
  264. internal string _serverName;
  265. //偡偱偵僋儘乕僘偝傟偨偐偳偆偐偺僼儔僌
  266. internal bool _closed;
  268. protected TerminalConnection(TerminalParam p, int width, int height) {
  269. _param = p;
  270. _width = width;
  271. _height = height;
  272. ResetLog(p.LogType, p.LogPath, p.LogAppend);
  273. _logsuspended = false;
  274. }
  276. public IPAddress ServerAddress {
  277. get {
  278. return _serverAddress;
  279. }
  280. }
  281. public string ServerName {
  282. get {
  283. return _serverName;
  284. }
  285. }
  286. public abstract string ProtocolDescription {
  287. get;
  288. }
  290. public int SentPacketCount {
  291. get {
  292. return _sentPacketCount;
  293. }
  294. }
  295. public int SentDataSize {
  296. get {
  297. return _sentDataSize;
  298. }
  299. }
  300. public int ReceivedPacketCount {
  301. get {
  302. return _receivedPacketCount;
  303. }
  304. }
  305. public int ReceivedDataSize {
  306. get {
  307. return _receivedDataSize;
  308. }
  309. }
  311. public TerminalParam Param {
  312. get {
  313. return _param;
  314. }
  315. }
  316. public int TerminalHeight {
  317. get {
  318. return _height;
  319. }
  320. }
  321. public int TerminalWidth {
  322. get {
  323. return _width;
  324. }
  325. }
  327. public bool LogSuspended {
  328. get {
  329. return _logsuspended;
  330. }
  331. set {
  332. _logsuspended = value;
  333. }
  334. }
  336. public LogType LogType {
  337. get {
  338. return _logType;
  339. }
  340. }
  341. public string LogPath {
  342. get {
  343. return _logPath;
  344. }
  345. }
  346. public void SetServerInfo(string host, IPAddress address) {
  347. _serverName = host;
  348. _serverAddress = address;
  349. }
  350. public void CommentLog(string comment) {
  351. _loggerT.Comment(comment);
  352. _loggerB.Comment(comment);
  353. }
  354. public ITerminalTextLogger TextLogger {
  355. get {
  356. return _loggerT;
  357. }
  358. }
  359. public ITerminalBinaryLogger BinaryLogger {
  360. get {
  361. return _loggerB;
  362. }
  363. }
  365. public bool IsClosed {
  366. get {
  367. return _closed;
  368. }
  369. }
  373. public abstract string[] ConnectionParameter { get; }
  375. public abstract bool Available { get; }
  377. public virtual void Resize(int width, int height) {
  378. Debug.Assert(width>0 && height>0);
  379. _width = width;
  380. _height = height;
  381. }
  383. public abstract ConnectionTag Reproduce(); //摨偠偲偙傠傊偺愙懕傪傕偆侾杮
  385. //廔椆張棟
  386. internal virtual void Close() {
  387. if(_loggerT!=null) {
  388. _loggerT.Flush();
  389. _loggerT.Close();
  390. _loggerT = null;
  391. }
  392. if(_loggerB!=null) {
  393. _loggerB.Flush();
  394. _loggerB.Close();
  395. _loggerB = null;
  396. }
  397. _closed = true;
  398. }
  399. //愙懕傪暵偠傞慜偺嵟屻偺傾僋僔儑儞丅偙偪傜偐傜愗傞偲偒偵偼偙傟傪傛傇傋偒偩偑丄僒乕僶偐傜愗偭偰偒偨偲偒偼屇傇昁梫側偟
  400. internal virtual void Disconnect() {
  401. }
  403. internal abstract void RepeatAsyncRead(IDataReceiver cb);
  406. public void WriteChars(char[] data) {
  407. byte[] b = _param.EncodingProfile.GetBytes(data);
  408. Write(b);
  409. }
  410. public void WriteChar(char data) {
  411. byte[] b = _param.EncodingProfile.GetBytes(data);
  412. Write(b);
  413. }
  414. public abstract void Write(byte[] data);
  415. public abstract void Write(byte[] data, int offset, int length);
  417. //僨僼僅儖僩幚憰偼嬻
  418. public virtual void AreYouThere() {
  419. throw new NotSupportedException("[AYT] unsupported");
  420. }
  421. public virtual void SendBreak() {
  422. throw new NotSupportedException("[Break] unsupported");
  423. }
  424. public virtual void SendKeepAliveData() {
  425. }
  427. internal void AddSentDataStats(int bytecount) {
  428. _sentPacketCount++;
  429. _sentDataSize += bytecount;
  430. }
  431. internal void AddReceivedDataStats(int bytecount) {
  432. _receivedPacketCount++;
  433. _receivedDataSize += bytecount;
  434. }
  436. public void ResetLog(LogType t, string path, bool append) {
  437. _logType = t;
  438. _logPath = path;
  440. if(_loggerT!=null) _loggerT.Close();
  441. if(_loggerB!=null) _loggerB.Close();
  443. switch(t) {
  444. case LogType.None:
  445. _loggerT = new NullTextLogger();
  446. _loggerB = new NullBinaryLogger();
  447. break;
  448. case LogType.Default:
  449. _loggerT = new DefaultLogger(new StreamWriter(path, append, Encoding.Default));
  450. _loggerB = new NullBinaryLogger();
  451. break;
  452. case LogType.Binary:
  453. _loggerT = new NullTextLogger();
  454. _loggerB = new BinaryLogger(new FileStream(path, append? FileMode.Append : FileMode.Create));
  455. break;
  456. case LogType.Xml:
  457. _loggerT = new XmlLogger(new StreamWriter(path, append, Encoding.UTF8), _param); //DebugLog偼UTF8
  458. _loggerB = new NullBinaryLogger();
  459. break;
  460. }
  461. _loggerT = new InternalLoggerT(_loggerT, this);
  462. _loggerB = new InternalLoggerB(_loggerB, this);
  463. _loggerT.TerminalResized(_width, _height);
  464. }
  467. private class InternalLoggerT : ITerminalTextLogger {
  468. private TerminalConnection _parent;
  469. private ITerminalTextLogger _logger;
  471. public InternalLoggerT(ITerminalTextLogger l, TerminalConnection p) {
  472. _parent = p;
  473. _logger = l;
  474. }
  476. public void Append(char ch) {
  477. if(!_parent.LogSuspended) _logger.Append(ch);
  478. }
  479. public void Append(char[] ch) {
  480. if(!_parent.LogSuspended) _logger.Append(ch);
  481. }
  482. public void Append(char[] ch, int offset, int length) {
  483. if(!_parent.LogSuspended) _logger.Append(ch,offset,length);
  484. }
  485. public void BeginEscapeSequence() {
  486. if(!_parent.LogSuspended) _logger.BeginEscapeSequence();
  487. }
  488. public void AbortEscapeSequence() {
  489. if(!_parent.LogSuspended) _logger.AbortEscapeSequence();
  490. }
  491. public void CommitEscapeSequence() {
  492. if(!_parent.LogSuspended) _logger.CommitEscapeSequence();
  493. }
  494. public void Comment(string comment) {
  495. if(!_parent.LogSuspended) _logger.Comment(comment);
  496. }
  497. public void Flush() {
  498. _logger.Flush();
  499. }
  500. public void Close() {
  501. _logger.Close();
  502. }
  503. public bool IsActive {
  504. get {
  505. return _logger.IsActive;
  506. }
  507. }
  508. public void PacketDelimiter() {
  509. if(!_parent.LogSuspended) _logger.PacketDelimiter();
  510. }
  511. public void TerminalResized(int width, int height) {
  512. if(!_parent.LogSuspended) _logger.TerminalResized(width, height);
  513. }
  514. public void WriteLine(GLine line) {
  515. if(!_parent.LogSuspended) _logger.WriteLine(line);
  516. }
  518. }
  519. private class InternalLoggerB : ITerminalBinaryLogger {
  520. private TerminalConnection _parent;
  521. private ITerminalBinaryLogger _logger;
  523. public InternalLoggerB(ITerminalBinaryLogger l, TerminalConnection p) {
  524. _parent = p;
  525. _logger = l;
  526. }
  528. public void Append(byte[] data, int offset, int length) {
  529. if(!_parent.LogSuspended) _logger.Append(data,offset,length);
  530. }
  531. public void Comment(string comment) {
  532. if(!_parent.LogSuspended) _logger.Comment(comment);
  533. }
  534. public void Flush() {
  535. _logger.Flush();
  536. }
  537. public void Close() {
  538. _logger.Close();
  539. }
  540. public bool IsActive {
  541. get {
  542. return _logger.IsActive;
  543. }
  544. }
  545. }
  546. }
  547. internal abstract class TCPTerminalConnection : TerminalConnection {
  549. protected bool _usingSocks;
  551. protected TCPTerminalConnection(TerminalParam p, int w, int h) : base(p, w, h) {
  552. _usingSocks = false;
  553. }
  554. public TCPTerminalParam TCPParam {
  555. get {
  556. return _param as TCPTerminalParam;
  557. }
  558. }
  559. public override string ProtocolDescription {
  560. get {
  561. string s = _param.MethodName;
  562. if(_usingSocks) s += GEnv.Strings.GetString("Caption.TCPTerminalConnection.UsingSOCKS");
  563. return s;
  564. }
  565. }
  567. //愝掕偼嵟弶偩偗峴偆
  568. public bool UsingSocks {
  569. get {
  570. return _usingSocks;
  571. }
  572. set {
  573. _usingSocks = value;
  574. }
  575. }
  576. }
  577. internal class SSHTerminalConnection : TCPTerminalConnection, ISSHConnectionEventReceiver, ISSHChannelEventReceiver {
  578. private SSHConnection _connection;
  579. private SSHChannel _channel;
  580. private MemoryStream _passwordBuffer;
  581. private bool _waitingSendBreakReply;
  582. public SSHTerminalConnection(TCPTerminalParam p, int width, int height) : base(p, width, height) {
  583. }
  585. public override ConnectionTag Reproduce() {
  586. SSHTerminalParam sshp = (SSHTerminalParam)_param.Clone();
  587. if(GEnv.Options.DefaultLogType!=LogType.None) {
  588. sshp.LogType = GEnv.Options.DefaultLogType;
  589. sshp.LogPath = GUtil.CreateLogFileName(sshp.ShortDescription);
  590. }
  591. else
  592. sshp.LogType = LogType.None;
  594. if(sshp.Method==ConnectionMethod.SSH2 && !this.IsClosed) { //SSH2偺偲偒偼僐僱僋僔儑儞傪嫟桳偟偰儅儖僠僠儍僱儖傪巊梡
  595. System.Drawing.Size sz = GEnv.Frame.TerminalSizeForNextConnection;
  596. SSHTerminalConnection newcon = new SSHTerminalConnection(sshp, sz.Width, sz.Height);
  597. newcon.FixConnection(_connection);
  598. newcon.OpenShell();
  599. newcon.SetServerInfo(_serverName, _serverAddress);
  600. return new ConnectionTag(newcon);
  601. }
  602. else { 
  603. bool pp_found = (sshp.Passphrase!=null && sshp.Passphrase.Length>0);
  604. if(sshp.Method==ConnectionMethod.SSH1 && !pp_found)
  605. throw new ApplicationException(GEnv.Strings.GetString("Message.SSHTerminalConnection.ReproduceErrorOnSSH1"));
  606. if(sshp.Method==ConnectionMethod.SSH2 && !pp_found && this.IsClosed)
  607. throw new ApplicationException(GEnv.Strings.GetString("Message.SSHTerminalConnection.ReproduceErrorOnSSH2"));
  608. HostKeyChecker checker = new HostKeyChecker(GEnv.Frame, sshp);
  609. return CommunicationUtil.CreateNewConnection(sshp, new HostKeyCheckCallback(checker.CheckHostKeyCallback));
  610. }
  611. }
  614. public void FixConnection(SSHConnection con) {
  615. _connection = con;
  616. }
  618. public SSHConnectionInfo ConnectionInfo {
  619. get {
  620. return _connection.ConnectionInfo;
  621. }
  622. }
  624. public void OpenShell() {
  625. _channel = _connection.OpenShell(this);
  626. }
  628. internal override void Disconnect() {
  629. Close();
  630. }
  632. internal override void Close() {
  633. if(_closed) return; //俀搙埲忋僋儘乕僘偟偰傕暃嶌梡側偟 
  634. base.Close();
  635. try {
  636. if(_channel!=null) _channel.Close();
  637. if(_connection.ChannelCount==0) {
  638. _connection.Close();
  639. }
  640. }
  641. catch(Exception ex) {
  642. GUtil.Warning(GEnv.Frame, GEnv.Strings.GetString("Message.SSHTerminalConnection.CloseError")+ex.Message);
  643. }
  644. }
  646. public override string[] ConnectionParameter {
  647. get {
  648. string[] d = new string[2];
  649. d[0] = String.Format("ServerVersionString: {0}", _connection.ConnectionInfo.ServerVersionString);
  650. d[1] = String.Format("EncryptionAlgorithm: {0}",_connection.ConnectionInfo.AlgorithmForReception.ToString());
  651. return d;
  652. }
  653. }
  654. public override bool Available {
  655. get {
  656. return !_closed && _connection.Available;
  657. }
  658. }
  659. public override void Write(byte[] buf) {
  660. if(_connection.AuthenticationResult==AuthenticationResult.Prompt)
  661. InputAuthenticationResponse(buf, 0, buf.Length);
  662. else {
  663. AddSentDataStats(buf.Length);
  664. _channel.Transmit(buf);
  665. }
  666. }
  667. public override void Write(byte[] buf, int offset, int length) {
  668. if(_connection.AuthenticationResult==AuthenticationResult.Prompt)
  669. InputAuthenticationResponse(buf, offset, length);
  670. else {
  671. AddSentDataStats(length);
  672. _channel.Transmit(buf, offset, length);
  673. }
  674. }
  676. //authentication process for keyboard-interactive
  677. private void InputAuthenticationResponse(byte[] buf, int offset, int length) {
  678. for(int i=offset; i<offset+length; i++) {
  679. byte b = buf[i];
  680. if(_passwordBuffer==null) _passwordBuffer = new MemoryStream();
  681. if(b==13 || b==10) { //CR/LF
  682. byte[] pwd = _passwordBuffer.ToArray();
  683. if(pwd.Length>0) {
  684. _passwordBuffer.Close();
  685. string[] response = new string[1];
  686. response[0] = Encoding.ASCII.GetString(pwd);
  687. OnData(Encoding.ASCII.GetBytes("rn"), 0, 2); //昞帵忋夵峴偟側偄偲奿岲埆偄
  688. if(((Granados.SSHCV2.SSH2Connection)_connection).DoKeyboardInteractiveAuth(response)==AuthenticationResult.Success)
  689. _channel = _connection.OpenShell(this);
  690. _passwordBuffer = null;
  691. }
  692. }
  693. else if(b==3 || b==27) { //Ctrl+C, ESC
  694. GEnv.GetConnectionCommandTarget(this).Disconnect();
  695. return;
  696. }
  697. else
  698. _passwordBuffer.WriteByte(b);
  699. }
  700. }
  702. //旕摨婜偵庴怣偡傞丅
  703. private IDataReceiver _callback;
  704. private MemoryStream _buffer;
  705. internal override void RepeatAsyncRead(IDataReceiver cb) {
  706. _callback = cb;
  707. if(_buffer!=null) {
  708. lock(this) {
  709. _buffer.Close();
  710. byte[] t = _buffer.ToArray();
  711. if(t.Length>0) _callback.DataArrived(t, 0, t.Length);
  712. _buffer = null;
  713. }
  714. }
  715. }
  718. public override void Resize(int width, int height) {
  719. if(_connection.AuthenticationResult!=AuthenticationResult.Success) return;
  720. base.Resize(width, height);
  721. if(!_closed)
  722. _channel.ResizeTerminal(width, height, 0, 0);
  723. }
  724. public override void SendBreak() {
  725. if(_connection.AuthenticationResult!=AuthenticationResult.Success) return;
  726. if(((TCPTerminalParam)_param).Method==ConnectionMethod.SSH1)
  727. base.SendBreak(); //偙傟偱嫅斲偵側傞
  728. else {
  729. _waitingSendBreakReply = true;
  730. ((Granados.SSHCV2.SSH2Channel)_channel).SendBreak(500);
  731. }
  732. }
  733. public override void SendKeepAliveData() {
  734. _connection.SendIgnorableData("keep alive");
  735. }
  737. public void OnChannelClosed() {
  738. if(!_closed)
  739. _callback.DisconnectedFromServer();
  740. }
  741. public void OnChannelEOF() {
  742. if(!_closed)
  743. _callback.DisconnectedFromServer();
  744. }
  745. public void OnData(byte[] data, int offset, int length) {
  746. if(_callback==null) { //RepeatAsyncRead偑屇偽傟傞慜偺僨乕僞傪廤傔偰偍偔
  747. lock(this) {
  748. if(_buffer==null) _buffer = new MemoryStream(0x100);
  749. _buffer.Write(data, offset, length);
  750. }
  751. }
  752. else
  753. _callback.DataArrived(data, offset, length);
  754. }
  755. public void OnAuthenticationPrompt(string[] msg) {
  756. for(int i=0; i<msg.Length; i++) {
  757. if(i!=0) msg[i] += "rn";
  758. byte[] buf = Encoding.ASCII.GetBytes(msg[i]);
  759. OnData(buf, 0, buf.Length);
  760. }
  761. }
  762. public void OnExtendedData(int type, byte[] data) {
  763. }
  764. public void OnMiscPacket(byte type, byte[] data, int offset, int length) {
  765. if(_waitingSendBreakReply) {
  766. _waitingSendBreakReply = false;
  767. if(type==(byte)Granados.SSHCV2.PacketType.SSH_MSG_CHANNEL_FAILURE)
  768. GEnv.InterThreadUIService.Warning(GEnv.Strings.GetString("Message.SSHTerminalconnection.BreakError"));
  769. }
  770. }
  771. public void OnConnectionClosed() {
  772. if(!_closed) {
  773. EnsureCallbackHandler();
  774. _callback.DisconnectedFromServer();
  775. }
  776. }
  777. public void OnDebugMessage(bool display, byte[] data) {
  778. Debug.WriteLine(String.Format("SSH debug {0}[{1}]", data.Length, data[0] ));
  779. }
  780. public void OnIgnoreMessage(byte[] data) {
  781. Debug.WriteLine(String.Format("SSH ignore {0}[{1}]", data.Length, data[0] ));
  782. }
  783. public void OnUnknownMessage(byte type, byte[] data) {
  784. Debug.WriteLine(String.Format("Unexpected SSH packet type {0}", type));
  785. }
  787. public void OnChannelReady() { //!!Transmit傪嫋壜偡傞捠抦偑昁梫丠
  788. }
  790. public void OnChannelError(Exception ex, string msg) {
  791. if(!_closed) {
  792. EnsureCallbackHandler();
  793. _callback.ErrorOccurred(msg);
  794. }
  795. }
  796. public void OnError(Exception ex, string msg) {
  797. if(!_closed) {
  798. EnsureCallbackHandler();
  799. _callback.ErrorOccurred(msg);
  800. }
  801. }
  803. public Granados.SSHC.PortForwardingCheckResult CheckPortForwardingRequest(string host, int port, string originator, int originator_port) {
  804. return new Granados.SSHC.PortForwardingCheckResult();
  805. }
  806. public void EstablishPortforwarding(ISSHChannelEventReceiver receiver, SSHChannel channel) {
  807. }
  809. private void EnsureCallbackHandler() {
  810. int n = 0;
  811. while(_callback==null && n++<10) //傢偢偐側帪娫嵎偱僴儞僪儔偑僙僢僩偝傟側偄偙偲傕偁傞
  812. Thread.Sleep(100);
  813. }
  814. }
  815. internal class TelnetTerminalConnection : TCPTerminalConnection, IDataReceiver {
  816. private AbstractGuevaraSocket _socket;
  817. private TelnetNegotiator _negotiator;
  819. public TelnetTerminalConnection(TerminalParam p, TelnetNegotiator neg, AbstractGuevaraSocket s, int width, int height) : base(p, width, height) {
  820. _socket = s;
  821. _negotiator = neg;
  822. }
  824. internal override void Close() {
  825. if(_closed) return; //俀搙埲忋僋儘乕僘偟偰傕暃嶌梡側偟 
  826. base.Close();
  827. try {
  828. _socket.Close();
  829. }
  830. catch(Exception ex) {
  831. GUtil.Warning(GEnv.Frame, GEnv.Strings.GetString("Message.SSHTerminalConnection.CloseError")+ex.Message);
  832. }
  833. }
  834. internal override void Disconnect() {
  835. }
  836. public override ConnectionTag Reproduce() {
  837. TerminalParam np = (TerminalParam)_param.Clone();
  838. if(GEnv.Options.DefaultLogType!=LogType.None) {
  839. np.LogType = GEnv.Options.DefaultLogType;
  840. np.LogPath = GUtil.CreateLogFileName(np.ShortDescription);
  841. }
  842. else
  843. np.LogType = LogType.None;
  845. return CommunicationUtil.CreateNewConnection(np);
  846. }
  849. public override string[] ConnectionParameter {
  850. get {
  851. string[] d = new string[1];
  852. d[0] = String.Format("");
  853. return d;
  854. }
  855. }
  857. public override bool Available {
  858. get {
  859. return !_closed && _socket.DataAvailable;
  860. }
  861. }
  863. private IDataReceiver _callback;
  864. internal override void RepeatAsyncRead(IDataReceiver cb) {
  865. if(_callback!=null) throw new InvalidOperationException("duplicated AsyncRead() is attempted");
  867. _callback = cb;
  868. _socket.RepeatAsyncRead(this);
  869. }
  871. public void DataArrived(byte[] buf, int offset, int count) {
  872. ProcessBuffer(buf, offset, offset+count);
  873. _negotiator.Flush(_socket);
  874. }
  876. public void DisconnectedFromServer() {
  877. if(!_closed)
  878. _callback.DisconnectedFromServer();
  879. }
  881. public void ErrorOccurred(string msg) {
  882. if(!_closed)
  883. _callback.ErrorOccurred(msg);
  884. }
  886. //CR NUL -> CR
  887. private void ProcessBuffer(byte[] buf, int offset, int limit) {
  888. while(offset < limit) {
  889. while(offset < limit && _negotiator.InProcessing) {
  890. if(_negotiator.Process(buf[offset++])==TelnetNegotiator.ProcessResult.REAL_0xFF)
  891. _callback.DataArrived(buf, offset-1, 1);
  892. }
  894. int delim = offset;
  895. while(delim < limit) {
  896. byte b = buf[delim];
  897. if(b==0xFF) {
  898. _negotiator.StartNegotiate();
  899. break;
  900. }
  901. if(b==0 && delim-1>=0 && buf[delim-1]==0x0D) break; //CR NUL僒億乕僩
  902. delim++;
  903. }
  905. if(delim>offset) _callback.DataArrived(buf, offset, delim-offset); //delim偺庤慜傑偱張棟
  906. offset = delim+1;
  907. }
  909. }
  911. public override void Resize(int width, int height) {
  912. base.Resize(width, height);
  913. if(!_closed) {
  914. TelnetOptionWriter wr = new TelnetOptionWriter();
  915. wr.WriteTerminalSize(width, height);
  916. wr.WriteTo(_socket);
  917. }
  918. }
  920. public override void Write(byte[] buf) {
  921. Write(buf, 0, buf.Length);
  922. }
  923. public override void Write(byte[] buf, int offset, int length) {
  924. AddSentDataStats(length);
  925. for(int i=0; i<length; i++) {
  926. byte t = buf[offset+i];
  927. if(t==0xFF || t==0x0D) { //0xFF傑偨偼CRLF埲奜偺CR傪尒偮偗偨傜
  928. WriteEscaping(buf, offset, length);
  929. return;
  930. }
  931. }
  932. _socket.Transmit(buf, offset, length); //戝掞偺応崌偼偙偆偄偆僨乕僞偼擖偭偰偄側偄偺偱丄崅懍壔偺偨傔偦偺傑傑憲傝弌偡
  933. }
  934. private void WriteEscaping(byte[] buf, int offset, int length) {
  935. byte[] newbuf = new byte[length*2];
  936. int newoffset = 0;
  937. for(int i=0; i<length; i++) {
  938. byte t = buf[offset+i];
  939. if(t==0xFF) {
  940. newbuf[newoffset++] = 0xFF;
  941. newbuf[newoffset++] = 0xFF; //俀屄
  942. }
  943. else if(t==0x0D/* && (i==length-1 || buf[offset+i+1]!=0x0A)*/) {
  944. newbuf[newoffset++] = 0x0D;
  945. newbuf[newoffset++] = 0x00;
  946. }
  947. else
  948. newbuf[newoffset++] = t;
  949. }
  950. _socket.Transmit(newbuf, 0, newoffset);
  951. }
  953. public override void AreYouThere() {
  954. byte[] data = new byte[2];
  955. data[0] = (byte)TelnetCode.IAC;
  956. data[1] = (byte)TelnetCode.AreYouThere;
  957. _socket.Transmit(data, 0, data.Length);
  958. }
  959. public override void SendBreak() {
  960. byte[] data = new byte[2];
  961. data[0] = (byte)TelnetCode.IAC;
  962. data[1] = (byte)TelnetCode.Break;
  963. _socket.Transmit(data, 0, data.Length);
  964. }
  965. public override void SendKeepAliveData() {
  966. byte[] data = new byte[2];
  967. data[0] = (byte)TelnetCode.IAC;
  968. data[1] = (byte)TelnetCode.NOP;
  969. _socket.Transmit(data, 0, data.Length);
  970. }
  973. }
  974. public class SerialTerminalConnection : TerminalConnection {
  975. private byte[] _buf;
  977. //僔儕傾儖偺旕摨婜捠怣傪偪傖傫偲傗傠偆偲偡傞偲.NET儔僀僽儔儕偱偼晄廫暘側偺偱傎傏API捈撉傒
  978. private IntPtr _fileHandle;
  980. private Win32.OVERLAPPED _readOL;
  981. private Win32.OVERLAPPED _writeOL;
  983. public SerialTerminalConnection(SerialTerminalParam p, IntPtr fh, int width, int height) : base(p, width, height) {
  984. _fileHandle = fh;
  985. _buf = new byte[0x1000];
  986. _readOL.hEvent  = Win32.CreateEvent(IntPtr.Zero, 0, 0, null);
  987. _writeOL.hEvent = Win32.CreateEvent(IntPtr.Zero, 0, 0, null);
  988. }
  989. internal override void Close() {
  990. if(_closed) return; //俀搙埲忋僋儘乕僘偟偰傕暃嶌梡側偟 
  991. base.Close();
  993. Win32.CloseHandle(_readOL.hEvent);
  994. Win32.CloseHandle(_writeOL.hEvent);
  995. Win32.CloseHandle(_fileHandle);
  996. _readOL.hEvent = _writeOL.hEvent = _fileHandle = IntPtr.Zero;
  997. //Debug.WriteLine("COM connection termingating...");
  998. }
  999. public override ConnectionTag Reproduce() {
  1000. throw new NotSupportedException(GEnv.Strings.GetString("Message.SerialTerminalConnection.ReproduceError"));
  1001. }
  1003. internal override void Disconnect() {
  1004. }
  1005. public override string ProtocolDescription {
  1006. get {
  1007. return "-";
  1008. }
  1009. }
  1011. public override string[] ConnectionParameter {
  1012. get {
  1013. string[] d = new string[6];
  1014. SerialTerminalParam p = (SerialTerminalParam)_param;
  1015. d[0] = String.Format("Port         : COM{0}", p.Port);
  1016. d[1] = String.Format("Baud rate    : {0}", p.BaudRate);
  1017. d[2] = String.Format("Data bits    : {0}", p.ByteSize);
  1018. d[3] = String.Format("Stop bits    : {0}", EnumDescAttribute.For(typeof(StopBits)).GetDescription(p.StopBits));
  1019. d[4] = String.Format("Parity       : {0}", EnumDescAttribute.For(typeof(Parity)).GetDescription(p.Parity));
  1020. d[5] = String.Format("Flow Control : {0}", EnumDescAttribute.For(typeof(FlowControl)).GetDescription(p.FlowControl));
  1021. return d;
  1022. }
  1023. }
  1024. public override bool Available {
  1025. get {
  1026. return false; //僔儕傾儖偩偲傛偔傢偐傜側偄偺偱false傪曉偟偰偍偔
  1027. }
  1028. }
  1029. private IDataReceiver _callback;
  1030. internal override void RepeatAsyncRead(IDataReceiver cb) {
  1031. if(_callback!=null) throw new InvalidOperationException("duplicated AsyncRead() is attempted");
  1033. _callback = cb;
  1034. GUtil.CreateThread(new ThreadStart(AsyncEntry)).Start();
  1035. //_stream.BeginRead(_buf, 0, _buf.Length, new AsyncCallback(RepeatCallback), null);
  1036. }
  1038. private void AsyncEntry() {
  1039. Win32.OVERLAPPED ol = new Win32.OVERLAPPED();
  1040. try {
  1041. //弶婜壔
  1042. bool success = false;
  1043. int len = 0, flags = 0;
  1044. ol.hEvent = Win32.CreateEvent(IntPtr.Zero, 0, 0, null);
  1045. success = Win32.ClearCommError(_fileHandle, out flags, IntPtr.Zero);
  1046. //偙偺SetCommMask傪幚峴偟側偄偲WaitCommEvent偑幐攕偟偰偟傑偆
  1047. success = Win32.SetCommMask(_fileHandle, 0);
  1048. success = Win32.SetCommMask(_fileHandle, 1); //EV_RXCHAR
  1050. byte[] buf = new byte[128];
  1051. while(true) {
  1052. success = Win32.WaitCommEvent(_fileHandle, out flags, ref ol); //偙偙偼晛捠false偑曉傞
  1053. if(!success && Win32.GetLastError()!=Win32.ERROR_IO_PENDING)
  1054. throw new Exception("WaitCommEvent failed " + Win32.GetLastError());
  1056. //偙偙偱僨乕僞偑棃傞傑偱僽儘僢僋偡傞丅偨偩丄僪僉儏儊儞僩偵傛傟偽WaitCommEvent偵懳墳偡傞GetOverlappedResult偼len偺抣偼柍堄枴偲偺偙偲
  1057. success = Win32.GetOverlappedResult(_fileHandle, ref ol, ref len, true);
  1058. if(!success) break; //偨偲偊偽愙懕傪愗傞側偳偱false偑曉偭偰偔傞
  1060. do {
  1061. len = 0;
  1062. success = Win32.ReadFile(_fileHandle, buf, buf.Length, ref len, ref _readOL);
  1063. //偙偺WaitForSingleObject偑昁梫偐偳偆偐偑傛偔傢偐傜側偄
  1064. //if(Win32.WaitForSingleObject(_readOL.hEvent, 5000)!=Win32.WAIT_OBJECT_0)
  1065. // throw new Exception("WaitForSingleObject timed out");
  1066. success = Win32.GetOverlappedResult(_fileHandle, ref _readOL, ref len, true);
  1067. if(len>0) _callback.DataArrived(buf, 0, len);
  1068. } while(len > 0);
  1069. }
  1070. }
  1071. catch(Exception ex) {
  1072. if(!_closed) {
  1073. _callback.ErrorOccurred(ex.Message);
  1074. }
  1075. }
  1076. finally {
  1077. Win32.CloseHandle(ol.hEvent);
  1078. //Debug.WriteLine("COM thread terminating...");
  1079. }
  1080. }
  1082. public override void Write(byte[] buf) {
  1083. Write(buf, 0, buf.Length);
  1084. }
  1085. public override void Write(byte[] data, int offset, int length) {
  1086. SerialTerminalParam sp = (SerialTerminalParam)_param;
  1087. if(sp.TransmitDelayPerChar==0) {
  1088. if(sp.TransmitDelayPerLine==0)
  1089. WriteMain(data, offset, length); //嵟傕扨弮
  1090. else { //夵峴偺傒僂僃僀僩憓擖
  1091. byte nl = (byte)(sp.TransmitNL==NewLine.CR? 13 : 10); 
  1092. int limit = offset+length;
  1093. int c = offset;
  1094. while(offset<limit) {
  1095. if(data[offset]==nl) {
  1096. WriteMain(data, c, offset-c+1);
  1097. Thread.Sleep(sp.TransmitDelayPerLine);
  1098. System.Windows.Forms.Application.DoEvents();
  1099. c = offset+1;
  1100. }
  1101. offset++;
  1102. }
  1103. if(c < limit) WriteMain(data, c, limit-c);
  1104. }
  1105. }
  1106. else {
  1107. byte nl = (byte)(sp.TransmitNL==NewLine.CR? 13 : 10); 
  1108. for(int i=0; i<length; i++) {
  1109. WriteMain(data, offset+i, 1);
  1110. Thread.Sleep(data[offset+i]==nl? sp.TransmitDelayPerLine : sp.TransmitDelayPerChar);
  1111. System.Windows.Forms.Application.DoEvents();
  1112. }
  1113. }
  1115. }
  1117. private void WriteMain(byte[] buf, int offset, int length) {
  1118. if(length==0) return; //挿偝侽偩偲 fixed(byte* p = buf) 偑幐攕偟偰偟傑偆
  1120. AddSentDataStats(length);
  1121. //_stream.Write(buf, 0, buf.Length);
  1122. int result = 0;
  1123. if(offset!=0) {
  1124. byte[] nb = new byte[length];
  1125. Array.Copy(buf, offset, nb, 0, length);
  1126. buf = nb; //師偺WriteFile偱offset偑侽偱側偄偲偒偼偡偖偵偼僒億乕僩偱偒側偄
  1127. }
  1128. bool success;
  1129. success = Win32.WriteFile(_fileHandle, buf, length, ref result, ref _writeOL);
  1130. if(Win32.GetLastError()!=Win32.ERROR_IO_PENDING)
  1131. throw new IOException("WriteFile failed for " + Win32.GetLastError());
  1132. //偙偺WaitForSingleObject偑昁梫偐偳偆偐偑傛偔傢偐傜側偄
  1133. //err = Win32.WaitForSingleObject(_writeOL.hEvent, 10000);
  1134. success = Win32.GetOverlappedResult(_fileHandle, ref _writeOL, ref result, true);
  1135. Debug.Assert(success);
  1136. }
  1137. public override void SendBreak() {
  1138. Win32.SetCommBreak(_fileHandle);
  1139. System.Threading.Thread.Sleep(500); //500ms懸婡
  1140. Win32.ClearCommBreak(_fileHandle);
  1141. }
  1143. public void ApplySerialParam(SerialTerminalParam param) {
  1144. //param偺撪梕偱DCB傪峏怴偟偰僙僢僩偟側偍偡
  1145. Win32.DCB dcb = new Win32.DCB();
  1146. CommunicationUtil.FillDCB(_fileHandle, ref dcb);
  1147. CommunicationUtil.UpdateDCB(ref dcb, param);
  1149. if(!Win32.SetCommState(_fileHandle, ref dcb))
  1150. throw new ArgumentException(GEnv.Strings.GetString("Message.SerialTerminalConnection.ConfigError"));
  1152. _param = param; //SetCommState偑惉岟偟偨傜峏怴
  1153. }
  1155. }
  1157. /*
  1158. public class ProcessConnection : TerminalConnection {
  1159. private Process _process;
  1160. private byte[] _bufOut;
  1161. private byte[] _bufErr;
  1163. public ProcessConnection(ProcessTerminalParam param, Process proc, int width, int height) : base(param, width, height) {
  1164. _process = proc;
  1165. _bufOut = new byte[0x1000];
  1166. _bufErr = new byte[0x1000];
  1167. }
  1168. internal override void Close() {
  1169. if(_closed) return; //俀搙埲忋僋儘乕僘偟偰傕暃嶌梡側偟 
  1170. base.Close();
  1172. }
  1173. public override ConnectionTag Reproduce() {
  1174. throw new NotSupportedException("僾儘僙僗傊偺愙懕偺暋惢偼偱偒傑偣傫丅");
  1175. }
  1177. internal override void Disconnect() {
  1178. _process.Close();
  1179. }
  1180. public override string ProtocolDescription {
  1181. get {
  1182. return "-";
  1183. }
  1184. }
  1186. public override string[] ConnectionParameter {
  1187. get {
  1188. string[] d = new string[1];
  1189. d[0] = ((ProcessTerminalParam)_param).Process;
  1190. return d;
  1191. }
  1192. }
  1193. public override bool Available {
  1194. get {
  1195. return false; 
  1196. }
  1197. }
  1198. private IDataReceiver _callback;
  1199. internal override void RepeatAsyncRead(IDataReceiver cb) {
  1200. if(_callback!=null) throw new InvalidOperationException("duplicated AsyncRead() is attempted");
  1202. _callback = cb;
  1203. _process.StandardOutput.BaseStream.BeginRead(_bufOut, 0, _bufOut.Length, new AsyncCallback(RepeatCallback), _bufOut);
  1204. _process.StandardError. BaseStream.BeginRead(_bufErr, 0, _bufErr.Length, new AsyncCallback(RepeatCallback), _bufErr);
  1205. }
  1206. private void RepeatCallback(IAsyncResult res) {
  1207. lock(this) {
  1208. try {
  1209. bool stderr = (res.AsyncState==_bufErr);
  1210. Stream strm = stderr? _process.StandardError.BaseStream : _process.StandardOutput.BaseStream;
  1211. int len = strm.EndRead(res);
  1212. //Debug.WriteLine(String.Format("RC {0} {1}", stderr, len));
  1213. byte[] buf = stderr? _bufErr : _bufOut;
  1214. if(len > 0) {
  1215. _callback.DataArrived(buf, 0, len);
  1216. strm.BeginRead(buf, 0, buf.Length, new AsyncCallback(RepeatCallback), buf);
  1217. }
  1218. else if(len < 0) {
  1219. strm.BeginRead(buf, 0, buf.Length, new AsyncCallback(RepeatCallback), buf);
  1220. }
  1221. else
  1222. _callback.DisconnectedFromServer();
  1223. }
  1224. catch(Exception ex) {
  1225. _callback.ErrorOccurred(ex.Message);
  1226. }
  1227. }
  1228. }
  1230. public override void Write(byte[] buf) {
  1231. Write(buf, 0, buf.Length);
  1232. }
  1233. public override void Write(byte[] data, int offset, int length) {
  1234. _process.StandardInput.BaseStream.Write(data, offset, length);
  1235. _process.StandardInput.BaseStream.Flush();
  1236. }
  1238. }
  1239. */
  1240. public class FakeConnection : TerminalConnection {
  1241. public FakeConnection(TerminalParam param) : base(param, 80, 25) {}
  1242. public override void Write(byte[] data) {
  1243. }
  1244. public override void Write(byte[] data, int offset, int length) {
  1245. }
  1246. internal override void RepeatAsyncRead(IDataReceiver r) {
  1247. }
  1248. public override string[] ConnectionParameter {
  1249. get {
  1250. return new string[1] { "fake connection" };
  1251. }
  1252. }
  1253. public override bool Available {
  1254. get {
  1255. return false;
  1256. }
  1257. }
  1258. public override string ProtocolDescription {
  1259. get {
  1260. return "";
  1261. }
  1262. }
  1263. public override ConnectionTag Reproduce() {
  1264. throw new NotSupportedException();
  1265. }
  1267. }
  1268. }