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);
     }
 }

 public SSH2PacketBuilder(IDataHandler handler)
     : base(handler)
 {
     _buffer = new DataFragment(0x1000);
     _packet = new DataFragment(_buffer.Capacity);
     _sequence = 0;
     _cipher = null;
     _mac = null;
     _head = null;
 }

        public override void OnData(DataFragment data)
        {
            lock (_cipherSync) {
                try {
                    if (!_keyError) {
                        // key error detection
                        if (_pending && DateTime.UtcNow > _keyErrorDetectionTimeout) {
                            _keyError = true;   // disable accepting data any more
                            return;
                        }

                        _buffer.Append(data);

                        if (!_pending) {
                            ProcessBuffer();
                        }
                    }
                } catch (Exception ex) {
                    OnError(ex);
                }
            }
        }

 /// <summary>
 /// Call OnData() of a core handler
 /// </summary>
 /// <param name="data"></param>
 protected void OnDataInternal(DataFragment data)
 {
     _innerHandler.OnData(data);
 }

 public SSH2TransmissionPacket()
 {
     _writer = new SSH2DataWriter();
     _dataFragment = new DataFragment(null, 0, 0);
     _isOpen = false;
 }

 /// <summary>
 /// Write data to the socket
 /// </summary>
 /// <param name="sock">socket object</param>
 /// <param name="data">data to write</param>
 public static void Write(this IGranadosSocket sock, DataFragment data)
 {
     if (data.Length > 0) {
         sock.Write(data.Data, data.Offset, data.Length);
     }
 }