Ejemplo n.º 1
0
        public int intUncompressedSize;   // Size of uncompressed message

        internal Message()
        {
            MessageDate     = DateTime.UtcNow;
            ExpirationDate  = DateTime.UtcNow.AddDays(21);
            enmState        = B2DecodeState.GetStartOfHeader;
            bytUncompressed = new byte[1];
            bytCompressed   = new byte[1];
        } // New - From Winlink
Ejemplo n.º 2
0
        } // New - From Winlink

        internal Message(string mId)
        {
            var messageStore = new MessageStore(DatabaseFactory.Get());
            var msg          = messageStore.GetToWinlinkMessage(mId);

            Mime            = UTF8Encoding.UTF8.GetString(msg);
            bytUncompressed = new byte[1];
            bytCompressed   = new byte[1];
            DecodeMime();
            PackB2Message();
            enmState = B2DecodeState.Inactive;
        } // New - To Winlink
Ejemplo n.º 3
0
        internal int BinaryInput(byte bytSingle)    // String version of the message subject
                                                    // String version of Offset to include in the header
                                                    // The current header size
                                                    // The current block size
                                                    // The initial size of the binary array buffer
        {
            // BinaryCount += 1
            // Disassembles the B2 binary byte stream, byte by byte...
            var switchExpr = enmState;

            switch (switchExpr)
            {
            case B2DecodeState.GetStartOfHeader:
            {
                if (bytSingle == SOH)
                {
                    sbdSubject.Length = 0;
                    strOffset         = "";
                    intB2Checksum     = 0;
                    intProgress       = 0;
                    bytCompressed     = new byte[intArraySize + 1];
                    enmState          = B2DecodeState.GetHeaderCount;
                }

                break;
            }

            case B2DecodeState.GetHeaderCount:
            {
                intHeaderSize = bytSingle;
                enmState      = B2DecodeState.GetSubject;
                break;
            }

            case B2DecodeState.GetSubject:
            {
                if (bytSingle != NUL)
                {
                    sbdSubject.Append((char)bytSingle);
                }
                else
                {
                    Subject = sbdSubject.ToString();
                    if (string.IsNullOrEmpty(Subject))
                    {
                        Subject = "---";
                    }
                    enmState = B2DecodeState.GetOffset;
                }

                break;
            }

            case B2DecodeState.GetOffset:
            {
                if (bytSingle != NUL)
                {
                    strOffset += ((char)bytSingle).ToString();
                }
                else
                {
                    enmState = B2DecodeState.GetStartOfBlock;
                    return(2);
                }

                break;
            }

            case B2DecodeState.GetStartOfBlock:
            {
                if (bytSingle == STX)
                {
                    enmState = B2DecodeState.GetBlockCount;
                }
                else if (bytSingle == EOT)
                {
                    enmState = B2DecodeState.GetChecksum;
                }
                else
                {
                    return(-1);
                }

                break;
            }

            case B2DecodeState.GetBlockCount:
            {
                intBlockSize = bytSingle;
                if (intBlockSize == 0)
                {
                    intBlockSize = 256;
                }
                enmState = B2DecodeState.GetDataBlock;
                break;
            }

            case B2DecodeState.GetDataBlock:
            {
                bytCompressed[intProgress] = bytSingle;
                intB2Checksum += bytSingle;
                intProgress   += 1;
                if (intProgress > bytCompressed.Length - 1)
                {
                    intArraySize += 10000;
                    Array.Resize(ref bytCompressed, intArraySize + 1);
                }

                intBlockSize -= 1;
                if (intBlockSize == 0)
                {
                    enmState = B2DecodeState.GetStartOfBlock;
                    return(2);
                }

                return(0);
            }

            case B2DecodeState.GetChecksum:
            {
                Array.Resize(ref bytCompressed, intProgress);
                intB2Checksum = (intB2Checksum & 0xFF) * -1 & 0xFF;
                if (bytSingle == intB2Checksum)
                {
                    return(1);
                }

                return(-2);
            }
            }

            return(default);