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

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

Telnet服务器

开发平台：

C#

TerminalBase.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: TerminalBase.cs,v 1.2 2005/04/20 08:45:47 okajima Exp $
  4. */
  5. using System;
  6. using System.Collections;
  7. using System.IO;
  8. using System.Text;
  9. using System.Threading;
  10. using System.Diagnostics;
  11. using System.Windows.Forms;
  13. using Poderosa.Log;
  14. using Poderosa.Config;
  15. using Poderosa.Connection;
  16. using Poderosa.ConnectionParam;
  17. using Poderosa.Text;
  18. using Poderosa.Communication;
  20. namespace Poderosa.Terminal
  21. {
  22. /// <summary>
  23. /// 僞乕儈僫儖
  24. /// 僨乕僞傪庴怣偟偰僪僉儏儊儞僩傪憖嶌偡傞婡擻傪傕偮丅
  25. /// </summary>
  26. internal abstract class AbstractTerminal : ITerminal {
  27. public abstract void ProcessChar(char ch);
  28. public abstract ProcessCharResult State { get; }
  29. public abstract byte[] SequenceKeyData(Keys modifier, Keys body);
  31. protected StringBuilder _bufferForMacro;
  32. protected AutoResetEvent _signalForMacro; //儅僋儘僗儗僢僪偵僨乕僞偺撉傒庢傝壜擻傪抦傜偣傞
  33. protected ICharDecoder     _decoder;
  34. protected GLineManipulator _manipulator;
  35. protected ITerminalTextLogger _logger; //Logger僾儘僷僥傿偲偺廳暋傪壗偲偐偟偨偄
  37. public ITerminalTextLogger Logger {
  38. get {
  39. return _tag.Connection.TextLogger;
  40. }
  41. }
  43. protected ConnectionTag  _tag;
  44. protected TextDecoration _currentdecoration;
  46. protected TerminalMode _terminalMode;
  47. protected TerminalMode _cursorKeyMode; //_terminalMode偼暿暔丅AIX偱偺vi偱丄僇乕僜儖僉乕偼晄曄偲偄偆椺偑妋擣偝傟偰偄傞
  49. public TerminalMode TerminalMode {
  50. get {
  51. return _terminalMode;
  52. }
  53. }
  54. public TerminalMode CursorKeyMode {
  55. get {
  56. return _cursorKeyMode;
  57. }
  58. }
  59. protected TerminalConnection GetConnection() {
  60. return _tag.Connection;
  61. }
  62. protected TerminalDocument GetDocument() {
  63. return _tag.Document;
  64. }
  66. protected abstract void ChangeMode(TerminalMode tm);
  67. protected abstract void ResetInternal();
  69. protected virtual void ChangeCursorKeyMode(TerminalMode tm) {
  70. _cursorKeyMode = tm;
  71. }
  73. /// <summary>
  74. /// 憖嶌偺懳徾偵側傞僪僉儏儊儞僩偲暥帤偺僄儞僐乕僨傿儞僌傪巜掕偟偰峔抸
  75. /// </summary>
  76. public AbstractTerminal(ConnectionTag tag, ICharDecoder decoder) {
  77. _tag = tag;
  78. _decoder = decoder;
  79. _terminalMode = TerminalMode.Normal;
  80. _currentdecoration = TextDecoration.Default;
  81. _manipulator = new GLineManipulator(80);
  82. _bufferForMacro = new StringBuilder();
  83. _signalForMacro = new AutoResetEvent(false);
  84. }
  85. public void Input(byte[] data, int offset, int length) {
  86. _manipulator.Load(GetDocument().CurrentLine, 0);
  87. _manipulator.CaretColumn = GetDocument().CaretColumn;
  88. _manipulator.DefaultDecoration = _currentdecoration;
  90. _decoder.Input(this, data, offset, length);
  92. GetDocument().ReplaceCurrentLine(_manipulator.Export());
  93. GetDocument().CaretColumn = _manipulator.CaretColumn;
  94. }
  95. public void Input(char[] data, int offset, int length) {
  96. _manipulator.Load(GetDocument().CurrentLine, 0);
  97. _manipulator.CaretColumn = GetDocument().CaretColumn;
  98. _manipulator.DefaultDecoration = _currentdecoration;
  100. for(int i=0; i<length; i++)
  101. ProcessChar(data[offset+i]);
  103. GetDocument().ReplaceCurrentLine(_manipulator.Export());
  104. GetDocument().CaretColumn = _manipulator.CaretColumn;
  105. }
  107. public void UnsupportedCharSetDetected(char code) {
  108. string desc;
  109. if(code=='0')
  110. desc = "0 (DEC Special Character)"; //偙傟偼傛偔偁傞偺偱扐偟彂偒偮偒
  111. else
  112. desc = new String(code, 1);
  114. if(GEnv.Options.WarningOption!=WarningOption.Ignore) {
  115. GEnv.InterThreadUIService.UnsupportedCharSetDetected(GetDocument(), String.Format(GEnv.Strings.GetString("Message.AbstractTerminal.UnsupportedCharSet"), desc));
  116. }
  117. }
  118. public void InvalidCharDetected(Encoding enc, byte[] buf) {
  119. if(GEnv.Options.WarningOption!=WarningOption.Ignore) {
  120. GEnv.InterThreadUIService.InvalidCharDetected(GetDocument(), String.Format(GEnv.Strings.GetString("Message.AbstractTerminal.UnexpectedChar"), enc.WebName));
  121. }
  122. }
  123. public void Reset() {
  124. //Encoding偑摨偠帪偼娙扨偵嵪傑偣傞偙偲偑偱偒傞
  125. if(_decoder.Encoding.Type==_tag.Connection.Param.Encoding)
  126. _decoder.Reset(_decoder.Encoding);
  127. else
  128. _decoder = new JapaneseCharDecoder(_tag.Connection);
  129. }
  130. //public void SetEncoding(EncodingProfile enc) {
  131. // _decoder.SetEncoding(enc);
  132. //}
  134. public void ClearMacroBuffer() {
  135. _bufferForMacro.Remove(0, _bufferForMacro.Length);
  136. _signalForMacro.Reset();
  137. }
  138. public void SignalData() {
  139. _signalForMacro.Set();
  140. }
  141. protected void AppendMacroBuffer(char ch) {
  142. if(ch!='r' && ch!='') {
  143. lock(_bufferForMacro) {
  144. _bufferForMacro.Append(ch); //!!挿偝偵忋尷傪偮偗偨傎偆偑埨慡偐傕
  145. }
  146. }
  147. }
  148. //儅僋儘幚峴僗儗僢僪偐傜屇偽傟傞侾峴撉傒弌偟儊僜僢僪
  149. public string ReadLineFromMacroBuffer() {
  150. do {
  151. int l = _bufferForMacro.Length;
  152. int i=0;
  153. for(i=0; i<l; i++) {
  154. if(_bufferForMacro[i]=='n') break;
  155. }
  157. if(l>0 && i<l) { //傔偱偨偔峴枛偑傒偮偐偭偨
  158. int j=i;
  159. if(i>0 && _bufferForMacro[i-1]=='r') j=i-1; //CRLF偺偲偒偼彍偄偰傗傞
  160. string r;
  161. lock(_bufferForMacro) {
  162. r = _bufferForMacro.ToString(0, j);
  163. _bufferForMacro.Remove(0, i+1);
  164. }
  165. return r;
  166. }
  167. else {
  168. _signalForMacro.Reset();
  169. _signalForMacro.WaitOne();
  170. }
  171. } while(true);
  172. }
  173. //儅僋儘幚峴僗儗僢僪偐傜屇偽傟傞丄乽壗偐僨乕僞偑偁傟偽慡晹傕偭偰偄偔乿儊僜僢僪
  174. public string ReadAllFromMacroBuffer() {
  175. if(_bufferForMacro.Length==0) {
  176. _signalForMacro.Reset();
  177. _signalForMacro.WaitOne();
  178. }
  180. lock(_bufferForMacro) {
  181. string r = _bufferForMacro.ToString();
  182. _bufferForMacro.Remove(0, _bufferForMacro.Length);
  183. return r;
  184. }
  185. }
  187. //偙傟偼儊僀儞僗儗僢僪偐傜屇傃弌偡偙偲
  188. public virtual void FullReset() {
  189. lock(_tag.Document) {
  190. ChangeMode(TerminalMode.Normal);
  191. _tag.Document.ClearScrollingRegion();
  192. ResetInternal();
  193. _decoder = new JapaneseCharDecoder(_tag.Connection);
  194. }
  195. }
  197. public void DumpCurrentText() {
  198. Debug.WriteLine(_manipulator.ToString());
  199. }
  201. }
  203. //Escape Sequence傪巊偆僞乕儈僫儖
  204. internal abstract class EscapeSequenceTerminal : AbstractTerminal {
  205. public EscapeSequenceTerminal(ConnectionTag tag, ICharDecoder decoder) : base(tag, decoder) {
  206. _escapeSequence = new StringBuilder();
  207. _processCharResult = ProcessCharResult.Processed;
  208. }
  210. private StringBuilder _escapeSequence;
  211. private ProcessCharResult _processCharResult;
  213. public override ProcessCharResult State {
  214. get {
  215. return _processCharResult;
  216. }
  217. }
  218. protected override void ResetInternal() {
  219. _escapeSequence = new StringBuilder();
  220. _processCharResult = ProcessCharResult.Processed;
  221. }
  223. public override void ProcessChar(char ch) {
  225. _logger = Logger; //_logger偼偙偺ProcessChar偺張棟撪偱偺傒桳岠丅
  227. if(_processCharResult != ProcessCharResult.Escaping) {
  228. if(ch==0x1B) {
  229. _processCharResult = ProcessCharResult.Escaping;
  230. } else {
  231. //!!媣偟傇傝偺偙偺偁偨傝傪尒傞偲偗偭偙偆墭偄暘婒偩側
  232. _logger.Append(ch);
  233. if(GEnv.Frame.MacroIsRunning) AppendMacroBuffer(ch);
  235. if(ch < 0x20 || (ch>=0x80 && ch<0xA0))
  236. _processCharResult = ProcessControlChar(ch);
  237. else
  238. _processCharResult = ProcessNormalChar(ch);
  239. }
  240. }
  241. else {
  242. if(ch=='') return; //僔乕働儞僗拞偵NULL暥帤偑擖偭偰偄傞働乕僗偑妋擣偝傟偨
  243. _escapeSequence.Append(ch);
  244. bool end_flag = false; //escape sequence偺廔傢傝偐偳偆偐傪帵偡僼儔僌
  245. if(_escapeSequence.Length==1) { //ESC+侾暥帤偱偁傞応崌
  246. end_flag = ('0'<=ch && ch<='9') || ('a'<=ch && ch<='z') || ('A'<=ch && ch<='Z') || ch=='>' || ch=='=' || ch=='|' || ch=='}' || ch=='~';
  247. }
  248. else if(_escapeSequence[0]==']') { //OSC偺廔抂偼BEL偐ST(String Terminator)
  249. end_flag = ch==0x07 || ch==0x9c; 
  250. }
  251. else {
  252. end_flag = ('a'<=ch && ch<='z') || ('A'<=ch && ch<='Z') || ch=='@' || ch=='~' || ch=='|' || ch=='{';
  253. }
  255. if(end_flag) { //僔乕働儞僗偺偍傢傝
  256. char[] seq = _escapeSequence.ToString().ToCharArray();
  257. _logger.BeginEscapeSequence();
  258. _logger.Append(seq, 0, seq.Length);
  259. _logger.CommitEscapeSequence();
  260. _logger.Flush();
  261. try {
  262. char code = seq[0];
  263. _processCharResult = ProcessCharResult.Unsupported; //ProcessEscapeSequence偱椺奜偑棃偨屻偱忬懺偑Escaping偼傂偳偄寢壥傪彽偔偺偱
  264. _processCharResult = ProcessEscapeSequence(code, seq, 1);
  265. if(_processCharResult==ProcessCharResult.Unsupported)
  266. throw new UnknownEscapeSequenceException(String.Format("ESC {0}", new string(seq)));
  267. }
  268. catch(UnknownEscapeSequenceException ex) {
  269. if(GEnv.Options.WarningOption!=Poderosa.Config.WarningOption.Ignore)
  270. GEnv.InterThreadUIService.UnsupportedEscapeSequence(GetDocument(), GEnv.Strings.GetString("Message.EscapesequenceTerminal.UnsupportedSequence")+ex.Message);
  271. }
  272. finally {
  273. _escapeSequence.Remove(0, _escapeSequence.Length);
  274. }
  275. }
  276. else
  277. _processCharResult = ProcessCharResult.Escaping;
  278. }
  279. }
  281. protected virtual ProcessCharResult ProcessControlChar(char ch) {
  282. if(ch=='n' || ch==0xB) { //Vertical Tab偼LF偲摍偟偄
  283. LineFeedRule rule = GetConnection().Param.LineFeedRule;
  284. if(rule==LineFeedRule.Normal || rule==LineFeedRule.LFOnly) {
  285. if(rule==LineFeedRule.LFOnly) //LF偺傒偺摦嶌偱偁傞偲偒
  286. DoCarriageReturn();
  287. DoLineFeed();
  288. }
  289. return ProcessCharResult.Processed;
  290. }
  291. else if(ch=='r') {
  292. LineFeedRule rule = GetConnection().Param.LineFeedRule;
  293. if(rule==LineFeedRule.Normal || rule==LineFeedRule.CROnly) {
  294. DoCarriageReturn();
  295. if(rule==LineFeedRule.CROnly)
  296. DoLineFeed();
  297. }
  298. return ProcessCharResult.Processed;
  299. }
  300. else if(ch==0x07) {
  301. _tag.Receiver.IndicateBell();
  302. return ProcessCharResult.Processed;
  303. }
  304. else if(ch==0x08) {
  305. //峴摢偱丄捈慜峴偺枛旜偑宲懕偱偁偭偨応崌峴傪栠偡
  306. if(_manipulator.CaretColumn==0) {
  307. TerminalDocument doc = GetDocument();
  308. int line = doc.CurrentLineNumber-1;
  309. if(line>=0 && doc.FindLineOrEdge(line).EOLType==EOLType.Continue) {
  310. doc.InvalidateLine(doc.CurrentLineNumber);
  311. doc.CurrentLineNumber = line;
  312. if(doc.CurrentLine==null)
  313. _manipulator.Clear(GetConnection().TerminalWidth);
  314. else
  315. _manipulator.Load(doc.CurrentLine, doc.CurrentLine.CharLength-1);
  316. doc.InvalidateLine(doc.CurrentLineNumber);
  317. }
  318. }
  319. else
  320. _manipulator.BackCaret();
  322. return ProcessCharResult.Processed;
  323. }
  324. else if(ch==0x09) {
  325. _manipulator.CaretColumn = GetNextTabStop(_manipulator.CaretColumn);
  326. return ProcessCharResult.Processed;
  327. }
  328. else if(ch==0x0E) {
  329. return ProcessCharResult.Processed; //埲壓俀偮偼CharDecoder偺拞偱張棟偝傟偰偄傞偼偢側偺偱柍帇
  330. }
  331. else if(ch==0x0F) {
  332. return ProcessCharResult.Processed;
  333. }
  334. else if(ch==0x00) {
  335. return ProcessCharResult.Processed; //null char偼柍帇 !!CR NUL傪CR LF偲傒側偡巇條偑偁傞偑丄CR LF CR NUL偲偔傞偙偲傕偁偭偰擄偟偄
  336. }
  337. else {
  338. //Debug.WriteLine("Unknown char " + (int)ch);
  339. //揔摉側僌儔僼傿僢僋昞帵傎偟偄
  340. return ProcessCharResult.Unsupported;
  341. }
  342. }
  343. private void DoLineFeed() {
  344. GLine nl = _manipulator.Export();
  345. nl.EOLType = (nl.EOLType==EOLType.CR || nl.EOLType==EOLType.CRLF)? EOLType.CRLF : EOLType.LF;
  346. _logger.WriteLine(nl); //儘僌偵峴傪commit
  347. GetDocument().ReplaceCurrentLine(nl);
  348. GetDocument().LineFeed();
  350. //僇儔儉曐帩偼昁梫丅僒儞僾儖:linuxconf.log
  351. int col = _manipulator.CaretColumn;
  352. _manipulator.Load(GetDocument().CurrentLine, col);
  353. }
  354. private void DoCarriageReturn() {
  355. _manipulator.CarriageReturn();
  356. }
  358. protected virtual int GetNextTabStop(int start) {
  359. int t = start;
  360. //t傛傝偱嵟彫偺俉偺攞悢傊傕偭偰偄偔
  361. t += (8 - t % 8);
  362. if(t >= _tag.Connection.TerminalWidth) t = _tag.Connection.TerminalWidth-1;
  363. return t;
  364. }
  366. protected virtual ProcessCharResult ProcessNormalChar(char ch) {
  367. //婛偵夋柺塃抂偵僉儍儗僢僩偑偁傞偺偵暥帤偑棃偨傜夵峴傪偡傞
  368. int tw = _tag.Connection.TerminalWidth;
  369. if(_manipulator.CaretColumn+GLine.CalcDisplayLength(ch) > tw) {
  370. GLine l = _manipulator.Export();
  371. l.EOLType = EOLType.Continue;
  372. GetDocument().ReplaceCurrentLine(l);
  373. GetDocument().LineFeed();
  374. _manipulator.Load(GetDocument().CurrentLine, 0);
  375. }
  377. //夋柺偺儕僒僀僘偑偁偭偨偲偒偼丄_manipulator偺僶僢僼傽僒僀僘偑晄懌偺壜擻惈偑偁傞
  378. if(tw > _manipulator.BufferSize)
  379. _manipulator.ExpandBuffer(tw);
  381. //捠忢暥帤偺張棟
  382. _manipulator.PutChar(ch, _currentdecoration);
  384. return ProcessCharResult.Processed;
  385. }
  387. protected abstract ProcessCharResult ProcessEscapeSequence(char code, char[] seq, int offset);
  389. //FormatException偺傎偐偵OverflowException偺壜擻惈傕偁傞偺偱
  390. protected static int ParseInt(string param, int default_value) {
  391. try {
  392. if(param.Length>0)
  393. return Int32.Parse(param);
  394. else
  395. return default_value;
  396. }
  397. catch(Exception ex) {
  398. throw new UnknownEscapeSequenceException(String.Format("bad number format [{0}] : {1}", param, ex.Message));
  399. }
  400. }
  402. protected static IntPair ParseIntPair(string param, int default_first, int default_second) {
  403. IntPair ret = new IntPair(default_first, default_second);
  405. string[] s = param.Split(';');
  407. if(s.Length >= 1 && s[0].Length>0) {
  408. try {
  409. ret.first = Int32.Parse(s[0]);
  410. }
  411. catch(Exception ex) {
  412. throw new UnknownEscapeSequenceException(String.Format("bad number format [{0}] : {1}", s[0], ex.Message));
  413. }
  414. }
  416. if(s.Length >= 2 && s[1].Length>0) {
  417. try {
  418. ret.second = Int32.Parse(s[1]);
  419. }
  420. catch(Exception ex) {
  421. throw new UnknownEscapeSequenceException(String.Format("bad number format [{0}] : {1}", s[1], ex.Message));
  422. }
  423. }
  425. return ret;
  426. }
  427. }
  428. }