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

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

Telnet服务器

开发平台：

C#

xmodem.cs：源码内容
  1. /*
  2. * Copyright (c) 2005 Poderosa Project, All Rights Reserved.
  3. * $Id: xmodem.cs,v 1.2 2005/04/20 08:45:48 okajima Exp $
  4. */
  5. using System;
  6. using System.Diagnostics;
  7. using System.IO;
  8. using System.Threading;
  10. using Poderosa.Connection;
  12. namespace Poderosa.Terminal
  13. {
  14. /// <summary>
  15. /// xmodem 偺奣梫偺愢柧偱偡丅
  16. /// </summary>
  17. public abstract class XModem : IModalTerminalTask {
  18. public const byte SOH = 1;
  19. public const byte STX = 2;
  20. public const byte EOT = 4;
  21. public const byte ACK = 6;
  22. public const byte NAK = 21;
  23. public const byte CAN = 24;
  24. public const byte SUB = 26;
  26. //忬懺捠抦
  27. public const int NOTIFY_SUCCESS = 0;
  28. public const int NOTIFY_PROGRESS = 1;
  29. public const int NOTIFY_ERROR = 2;
  30. public const int NOTIFY_TIMEOUT = 3;
  33. //CRC
  34. public static ushort CalcCRC(byte[] data, int offset, int length) {
  35. ushort crc = 0;
  36. for(int i=0; i<length; i++) {
  37. byte d = data[offset+i];
  38. /*
  39. int count = 8;
  40. while(--count>=0) {
  41. if((crc & 0x8000)!=0) {
  42. crc <<= 1;
  43. crc += (((d<<=1) & 0x0400) != 0);
  44. crc ^= 0x1021;
  45. }
  46. else {
  47. crc <<= 1;
  48. crc += (((d<<=1) & 0x0400) != 0);
  49. }
  50. }
  51. */
  52. crc ^= (ushort)((ushort)d << 8);
  53. for(int j=1; j<=8; j++) {
  54. if((crc & 0x8000)!=0)
  55. crc = (ushort)((crc<<1) ^ (ushort)0x1021);
  56. else
  57. crc <<= 1;
  58. }
  59. }
  60. return crc;
  61. }
  63. protected ConnectionTag _tag;
  64. protected string _fileName;
  65. protected byte _sequenceNumber;
  66. protected long _processedLength;
  67. protected bool _crcEnabled;
  68. protected Stream _stream;
  69. protected Timer _timer;
  70. protected IntPtr _notifyTarget;
  72. public XModem(ConnectionTag tag, string fn) {
  73. _tag = tag;
  74. _fileName = fn;
  75. _sequenceNumber = 1;
  76. }
  77. public bool CRCEnabled {
  78. get {
  79. return _crcEnabled;
  80. }
  81. }
  82. public IntPtr NotifyTarget {
  83. get {
  84. return _notifyTarget;
  85. }
  86. set {
  87. _notifyTarget = value;
  88. }
  89. }
  90. public abstract void Start();
  91. public abstract void Abort();
  93. public abstract void Input(byte[] data, int offset, int count);
  94. public bool CanReceive {
  95. get {
  96. return true;
  97. }
  98. }
  99. public string Caption {
  100. get {
  101. return "XMODEM";
  102. }
  103. }
  105. protected void NotifyStatus(int wparam, int lparam) {
  106. if(_notifyTarget==IntPtr.Zero) return;
  107. Win32.SendMessage(_notifyTarget, GConst.WMG_XMODEM_UPDATE_STATUS, new IntPtr(wparam), new IntPtr(lparam));
  108. }
  109. }
  111. public class XModemReceiver : XModem {
  112. private int _retryCount;
  113. private MemoryStream _buffer;
  115. //private FileStream _debugStream;
  117. private const int CRC_TIMEOUT = 1;
  118. private const int NEGOTIATION_TIMEOUT = 2;
  120. public XModemReceiver(ConnectionTag tag, string filename) : base(tag, filename) {
  121. _stream = new FileStream(_fileName, FileMode.Create, FileAccess.Write);
  122. }
  123. public override void Start() {
  124. _tag.ModalTerminalTask = this;
  125. _timer = new Timer(new TimerCallback(OnTimeout), CRC_TIMEOUT, 3000, Timeout.Infinite);
  126. _crcEnabled = true;
  127. _tag.Connection.Write(new byte[] { (byte)'C' }); //CRC儌乕僪偱僩儔僀
  129. //_debugStream = new FileStream("C:\IOPort\xmodemtest.bin", FileMode.Create, FileAccess.Write);
  130. }
  133. private void OnTimeout(object state) {
  134. _timer.Dispose();
  135. _timer = null;
  136. switch((int)state){ 
  137. case CRC_TIMEOUT:
  138. _crcEnabled = false;
  139. _timer = new Timer(new TimerCallback(OnTimeout), NEGOTIATION_TIMEOUT, 5000, Timeout.Infinite);
  140. _tag.Connection.Write(new byte[] { NAK });
  141. break;
  142. case NEGOTIATION_TIMEOUT:
  143. _tag.Connection.Write(new byte[] { CAN });
  144. GEnv.InterThreadUIService.Warning(GEnv.Strings.GetString("Message.XModem.StartTimedOut"));
  145. NotifyStatus(NOTIFY_TIMEOUT, 0);
  146. Exit();
  147. break;
  148. }
  150. }
  151. private void Exit() {
  152. _tag.ModalTerminalTask = null;
  153. _stream.Close();
  154. if(_timer!=null) _timer.Dispose();
  155. }
  156. public override void Abort() {
  157. _tag.Connection.Write(new byte[] { CAN });
  158. Exit();
  159. }
  161. public override void Input(byte[] data, int offset, int count) {
  162. if(_timer!=null) {
  163. _timer.Dispose();
  164. _timer = null;
  165. }
  167. //Debug.WriteLine(String.Format("Received {0}", count));
  168. //_debugStream.Write(data, offset, count);
  169. //_debugStream.Flush();
  170. AdjustBuffer(ref data, ref offset, ref count);
  172. byte head = data[offset];
  173. if(head==EOT) { //successfully exit
  174. _tag.Connection.Write(new byte[] { ACK });
  175. GEnv.InterThreadUIService.Information(GEnv.Strings.GetString("Message.XModem.ReceiveComplete"));
  176. NotifyStatus(NOTIFY_SUCCESS, 0);
  177. //_debugStream.Close();
  178. Exit();
  179. }
  180. else {
  181. int required = 3+(head==STX? 1024 : 128)+(_crcEnabled? 2 : 1);
  182. if(required>count) {
  183. ReserveBuffer(data, offset, count); //搑拞偱愗傟偰偄偨応崌
  184. //Debug.WriteLine(String.Format("Reserving #{0} last={1} offset={2} count={3}", seq, last, offset, count));
  185. return;
  186. }
  188. byte seq  = data[offset+1];
  189. byte neg  = data[offset+2];
  190. if(seq!=_sequenceNumber || seq+neg!=255) {
  191. Abort();
  192. GEnv.InterThreadUIService.Warning(GEnv.Strings.GetString("Message.XModem.SequenceError"));
  193. NotifyStatus(NOTIFY_ERROR, 0);
  194. }
  195. else {
  196. //Debug.WriteLine(String.Format("Processing #{0}", seq));
  197. bool success;
  198. int  body_offset = offset+3;
  199. int  body_len = head==STX? 1024 : 128;
  200. int  checksum_offset = offset+3+body_len;
  201. if(_crcEnabled) {
  202. ushort sent = (ushort)( (((ushort)data[checksum_offset])<<8) + (ushort)data[checksum_offset+1] );
  203. ushort sum  = CalcCRC(data, body_offset, body_len);
  204. success = (sent==sum);
  205. }
  206. else {
  207. byte sent = data[checksum_offset];
  208. byte sum = 0;
  209. for(int i=body_offset; i<checksum_offset; i++) sum += data[i];
  210. success = (sent==sum);
  211. }
  213. _buffer = null; //僽儘僢僋偛偲偵ACK傪懸偮巇條側偺偱丄傕傜偭偰偒偨僨乕僞偑暋悢僽儘僢僋偵傑偨偑傞偙偲偼側偄丅偟偨偑偭偰偙偙偱攋婞偟偰峔傢側偄丅
  214. if(success) {
  215. _tag.Connection.Write(new byte[] { ACK });
  216. _sequenceNumber++;
  218. int t = checksum_offset-1;
  219. while(t>=body_offset && data[t]==26) t--; //Ctrl+Z偱杽傑偭偰偄傞偲偙傠偼柍帇
  220. int len = t+1 - body_offset;
  221. _stream.Write(data, body_offset, len);
  222. _processedLength += len;
  223. NotifyStatus(NOTIFY_PROGRESS, (int)_processedLength);
  224. _retryCount = 0;
  225. }
  226. else {
  227. //_debugStream.Close();
  228. if(++_retryCount==3) { //傕偆偁偒傜傔傞
  229. Abort();
  230. GEnv.InterThreadUIService.Warning(GEnv.Strings.GetString("Message.XModem.CheckSumError"));
  231. NotifyStatus(NOTIFY_ERROR, 0);
  232. }
  233. else {
  234. _tag.Connection.Write(new byte[] { NAK });
  235. }
  236. }
  238. }
  239. }
  240. }
  242. private void ReserveBuffer(byte[] data, int offset, int count) {
  243. _buffer = new MemoryStream();
  244. _buffer.Write(data, offset, count);
  245. }
  246. private void AdjustBuffer(ref byte[] data, ref int offset, ref int count) {
  247. if(_buffer==null || _buffer.Position==0) return;
  249. _buffer.Write(data, offset, count);
  250. count = (int)_buffer.Position;
  251. _buffer.Close();
  252. data = _buffer.ToArray();
  253. Debug.Assert(data.Length==count);
  254. offset = 0;
  255. }
  257. }
  259. public class XModemSender : XModem {
  260. private bool _negotiating;
  261. private int _retryCount;
  262. private byte[] _body;
  263. private int _offset;
  264. private int _nextOffset;
  266. //private FileStream _debugStream;
  268. private const int NEGOTIATION_TIMEOUT = 1;
  270. public int TotalLength {
  271. get {
  272. return _body.Length;
  273. }
  274. }
  276. public XModemSender(ConnectionTag tag, string filename) : base(tag, filename) {
  277. _body = new byte[new FileInfo(filename).Length];
  278. FileStream strm = new FileStream(filename, FileMode.Open, FileAccess.Read);
  279. strm.Read(_body, 0, _body.Length);
  280. strm.Close();
  281. }
  282. public override void Start() {
  283. _tag.ModalTerminalTask = this;
  284. _timer = new Timer(new TimerCallback(OnTimeout), NEGOTIATION_TIMEOUT, 60000, Timeout.Infinite);
  285. _negotiating = true;
  286. //_tag.Connection.WriteChars(TerminalUtil.NewLineChars(_tag.Connection.Param.TransmitNL));
  287. }
  289. private void OnTimeout(object state) {
  290. _timer.Dispose();
  291. _timer = null;
  292. switch((int)state){ 
  293. case NEGOTIATION_TIMEOUT:
  294. GEnv.InterThreadUIService.Warning(GEnv.Strings.GetString("Message.XModem.StartTimedOut"));
  295. NotifyStatus(NOTIFY_TIMEOUT, 0);
  296. Exit();
  297. break;
  298. }
  300. }
  301. private void Exit() {
  302. _tag.ModalTerminalTask = null;
  303. if(_timer!=null) _timer.Dispose();
  304. }
  305. public override void Abort() {
  306. _tag.Connection.Write(new byte[] { CAN });
  307. Exit();
  308. }
  310. public override void Input(byte[] data, int offset, int count) {
  311. if(_timer!=null) {
  312. _timer.Dispose();
  313. _timer = null;
  314. }
  316. if(_negotiating) {
  317. for(int i=0; i<count; i++) {
  318. byte t = data[offset+i];
  319. if(t==NAK || t==(byte)'C') {
  320. _crcEnabled = t==(byte)'C';
  321. _negotiating = false;
  322. _sequenceNumber = 1;
  323. _offset = _nextOffset = 0;
  324. break;
  325. }
  326. }
  327. if(_negotiating) return; //偁偨傑偑偒偰偄側偄
  328. }
  329. else {
  330. byte t = data[offset];
  331. if(t==ACK) {
  332. _sequenceNumber++;
  333. _retryCount = 0;
  334. if(_offset==_body.Length) { //successfully exit
  335. Exit();
  336. GEnv.InterThreadUIService.Information(GEnv.Strings.GetString("Message.XModem.SendComplete"));
  337. NotifyStatus(NOTIFY_SUCCESS, 0);
  338. return;
  339. }
  340. _offset = _nextOffset;
  341. }
  342. else if(t!=NAK || (++_retryCount==3)) {
  343. Abort();
  344. GEnv.InterThreadUIService.Warning(GEnv.Strings.GetString("Message.XModem.BlockStartError"));
  345. NotifyStatus(NOTIFY_ERROR, 0);
  346. return;
  347. }
  348. }
  350. if(_nextOffset>=_body.Length) { //last
  351. _tag.Connection.Write(new byte[] { EOT });
  352. _offset = _body.Length;
  353. }
  354. else {
  355. int len = 128;
  356. if(_crcEnabled && _offset+1024<=_body.Length) len = 1024;
  357. byte[] buf = new byte[3+len+(_crcEnabled? 2 : 1)];
  358. buf[0] = len==128? SOH : STX;
  359. buf[1] = (byte)_sequenceNumber;
  360. buf[2] = (byte)(255 - buf[1]);
  361. int body_len = Math.Min(len, _body.Length-_offset);
  362. Array.Copy(_body, _offset, buf, 3, body_len);
  363. for(int i=body_len; i<len; i++)
  364. buf[3+i] = 26; //padding
  365. if(_crcEnabled) {
  366. ushort sum  = CalcCRC(buf, 3, len);
  367. buf[3+len  ] = (byte)(sum >> 8);
  368. buf[3+len+1] = (byte)(sum & 0xFF);
  369. }
  370. else {
  371. byte sum = 0;
  372. for(int i=0; i<len; i++) sum += buf[3+i];
  373. buf[3+len] = sum;
  374. }
  376. _nextOffset = _offset + len;
  377. _tag.Connection.Write(buf, 0, buf.Length);
  378. NotifyStatus(NOTIFY_PROGRESS, _nextOffset);
  379. //Debug.WriteLine("Transmitted "+_sequenceNumber+" " +_offset);
  380. }
  382. }
  385. }
  386. }