C# IO.DataFragment类代码示例

        public void Close(Cipher cipher, Random rnd, MAC mac, int sequence, DataFragment result) {
            if(!_is_open) throw new SSHException("internal state error");
            
            int blocksize = cipher==null? 8 : cipher.BlockSize;
            int payload_length = _writer.Length - (SEQUENCE_MARGIN + LENGTH_MARGIN + PADDING_MARGIN);
            int r = 11 - payload_length % blocksize;
            while(r < 4) r += blocksize;
            _paddingLength = r;
            _packetLength = PADDING_MARGIN + payload_length + _paddingLength;
            int image_length = _packetLength + LENGTH_MARGIN;

            //fill padding
            for(int i=0; i<_paddingLength; i+=4)
                _writer.Write(rnd.Next());

            //manipulate stream
            byte[] rawbuf = _writer.UnderlyingBuffer;
            SSHUtil.WriteIntToByteArray(rawbuf, 0, sequence);
            SSHUtil.WriteIntToByteArray(rawbuf, SEQUENCE_MARGIN, _packetLength);
            rawbuf[SEQUENCE_MARGIN + LENGTH_MARGIN] = (byte)_paddingLength;

            //mac
            if(mac!=null) {
                _mac = mac.ComputeHash(rawbuf, 0, _packetLength+LENGTH_MARGIN+SEQUENCE_MARGIN);
                Array.Copy(_mac, 0, rawbuf, _packetLength+LENGTH_MARGIN+SEQUENCE_MARGIN, _mac.Length);
                image_length += _mac.Length;
            }

            //encrypt
            if(cipher!=null)
                cipher.Encrypt(rawbuf, SEQUENCE_MARGIN, _packetLength+LENGTH_MARGIN, rawbuf, SEQUENCE_MARGIN);

            result.Init(rawbuf, SEQUENCE_MARGIN, image_length);
            _is_open = false;
        }

        private int _requiredResponseCount; //for keyboard-interactive authentication

        internal SSH2Connection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver r, string serverversion, string clientversion) : base(param, strm, r) {
            _cInfo = new SSH2ConnectionInfo();
            _cInfo._serverVersionString = serverversion;
            _cInfo._clientVersionString = clientversion;
            
            _packetReceiver = new SynchronizedPacketReceiver(this);
            _packetBuilder = new SSH2PacketBuilder(_packetReceiver);
            _transmissionPacket = new SSH2TransmissionPacket();
            _transmissionImage = new DataFragment(null, 0, 0);
        }

		public void Append(DataFragment data) {
			if(_length==0) {
    			AssureCapacity(RoundUp(data.Length));
    			Array.Copy(data.Data, data.Offset, _data, 0, data.Length);
                _offset = 0;
				_length = data.Length;
			}
			else {
				Append(data.Data, data.Offset, data.Length);
			}
		}

 private void Init(DataFragment data)
 {
     _data = data.Data;
     _offset = data.Offset;
     _limit = _offset + data.Length;
 }

 public void OnData(DataFragment data)
 {
     _connection.AsyncReceivePacket(data);
 }

 private SSH1PacketType SneakPacketType(DataFragment data)
 {
     return (SSH1PacketType)data[0];
 }

        public void StartReceivingThread(Action<DataFragment> onDataCallback, Action onClosedCallback)
        {
            if (_socket == null || _receivingThread != null) {
                return;
            }

            _receivingThread = new Thread(() => {
                byte[] buffer = new byte[0x20000];
                DataFragment dataFrag = new DataFragment(buffer, 0, 0);

                try {
                    while (true) {
                        int received = _socket.Receive(buffer, 0, buffer.Length, SocketFlags.None);
                        if (received > 0) {
                            dataFrag.SetLength(0, received);
                            onDataCallback(dataFrag);
                        }
                    }
                }
                catch (Exception e) {
                    if (!_shutdown) {
                        System.Diagnostics.Debug.WriteLine(e.Message);
                        System.Diagnostics.Debug.WriteLine(e.StackTrace);
                    }

                    if (!_socket.Connected && !_shutdown) {
                        // closed by the peer
                        onClosedCallback();
                    }
                }
            });
            _receivingThread.Start();
        }

 public SSH2MsgNewKeys(DataFragment data, Handler onDequeued)
     : base(data.Data, data.Offset, data.Length)
 {
     _onDequeued = onDequeued;
 }

 private bool IsMsgNewKeys(DataFragment packet)
 {
     return packet.Length >= 1 && packet.ByteAt(0) == (byte)PacketType.SSH_MSG_NEWKEYS;
 }

 /// <summary>
 /// Handle data instead of the core handler.
 /// </summary>
 /// <param name="data">data</param>
 protected abstract void FilterData(DataFragment data);

 /// <summary>
 /// Implements <see cref="IDataHandler"/>
 /// </summary>
 /// <param name="data"></param>
 public void OnData(DataFragment data)
 {
     FilterData(data);
 }

 public void Write(DataFragment data)
 {
     Write(data.Data, data.Offset, data.Length);
 }

 /// <summary>
 /// Make another view of this instance.
 /// </summary>
 /// <param name="startIndex">start index for the new view.</param>
 public DataFragment MakeView(int startIndex)
 {
     if (startIndex < 0 || startIndex > _length) {
         throw new ArgumentOutOfRangeException();
     }
     DataFragment newInstance = new DataFragment(_data, _offset + startIndex, _length - startIndex);
     return newInstance;
 }

 // for debug
 private void Dump(string caption, DataFragment data)
 {
     Dump(caption, data.Data, data.Offset, data.Length);
 }

 public override void OnData(DataFragment data)
 {
     #if DUMP_PACKET
     Dump("SCP: OnData", data);
     #endif
     if (_dataHandler != null) {
         _dataHandler(data);
     }
 }