/// <summary>
 /// Process a static virtual channel received
 /// </summary>
 /// <param name="packet"></param>
 public override void ReceivePackets(StackPacket packet)
 {
     if (packet is Virtual_Channel_RAW_Server_Pdu)
     {
         Virtual_Channel_Complete_Server_Pdu reassembledPacket = ReassembleChunkData(packet as Virtual_Channel_RAW_Server_Pdu);
         if (reassembledPacket != null)
         {
             ProcessSVCData(reassembledPacket.virtualChannelData);
         }
     }
 }
        /// <summary>
        /// Reassemble static virtual channel PDU
        /// </summary>
        /// <param name="pdu"></param>
        /// <returns></returns>
        internal Virtual_Channel_Complete_Server_Pdu ReassembleChunkData(Virtual_Channel_RAW_Server_Pdu pdu)
        {
            if (pdu == null || pdu.virtualChannelData == null)
            {
                return(null);
            }

            // the first chunk
            if ((pdu.channelPduHeader.flags & CHANNEL_PDU_HEADER_flags_Values.CHANNEL_FLAG_FIRST)
                == CHANNEL_PDU_HEADER_flags_Values.CHANNEL_FLAG_FIRST)
            {
                completeServerPdu           = new Virtual_Channel_Complete_Server_Pdu();
                completeServerPdu.rawPdus   = new System.Collections.ObjectModel.Collection <Virtual_Channel_RAW_Server_Pdu>();
                completeServerPdu.channelId = channelId;
                decompressedBuffer.Clear();
            }



            byte[] decompressedData = pdu.virtualChannelData;

            if (mppcDecompressor != null)   // has compression
            {
                CompressMode flag = CompressMode.None;

                if ((pdu.channelPduHeader.flags & CHANNEL_PDU_HEADER_flags_Values.CHANNEL_PACKET_AT_FRONT)
                    == CHANNEL_PDU_HEADER_flags_Values.CHANNEL_PACKET_AT_FRONT)
                {
                    flag |= CompressMode.SetToFront;
                }

                if ((pdu.channelPduHeader.flags & CHANNEL_PDU_HEADER_flags_Values.CHANNEL_PACKET_COMPRESSED)
                    == CHANNEL_PDU_HEADER_flags_Values.CHANNEL_PACKET_COMPRESSED)
                {
                    flag |= CompressMode.Compressed;
                }

                if ((pdu.channelPduHeader.flags & CHANNEL_PDU_HEADER_flags_Values.CHANNEL_PACKET_FLUSHED)
                    == CHANNEL_PDU_HEADER_flags_Values.CHANNEL_PACKET_FLUSHED)
                {
                    flag |= CompressMode.Flush;
                }

                if (flag != CompressMode.None)
                {
                    decompressedData = mppcDecompressor.Decompress(pdu.virtualChannelData, flag);
                }
            }


            if (completeServerPdu != null)
            {
                completeServerPdu.rawPdus.Add(pdu);
                decompressedBuffer.AddRange(decompressedData);
            }
            else
            {
                // not need to reassemble
                Virtual_Channel_Complete_Server_Pdu returnPDU = new Virtual_Channel_Complete_Server_Pdu();
                returnPDU.rawPdus   = new System.Collections.ObjectModel.Collection <Virtual_Channel_RAW_Server_Pdu>();
                returnPDU.channelId = channelId;
                returnPDU.rawPdus.Add(pdu);
                returnPDU.virtualChannelData = decompressedData;
                return(returnPDU);
            }

            // the last chunk
            if ((pdu.channelPduHeader.flags & CHANNEL_PDU_HEADER_flags_Values.CHANNEL_FLAG_LAST)
                == CHANNEL_PDU_HEADER_flags_Values.CHANNEL_FLAG_LAST)
            {
                if (decompressedBuffer != null)
                {
                    completeServerPdu.virtualChannelData = decompressedBuffer.ToArray();
                }
                Virtual_Channel_Complete_Server_Pdu returnPDU = completeServerPdu;
                completeServerPdu = null;
                return(returnPDU);
            }

            return(null);
        }