SmartDeviceClient/SmartProtocolStack/Segment.cs

using System;
using GPRSWeb.SmartDeviceClient.Common;
using GPRSWeb.SmartDeviceClient.SmartProtocolStack.RemoteHost;

namespace GPRSWeb.SmartDeviceClient.SmartProtocolStack
{
        public class Segment {

                private SegmentHeaders headers;
                private SegmentData data;

                public SegmentHeaders Headers {
                        get { return headers; }
                        set { headers = value; }
                }

                public SegmentData Data {
                        get { return data; }
                        set { data = value; }
                }

                public bool IsRetransmission {
                        get { return headers.IsRetransmission; }
                        set { headers.IsRetransmission = value; }
                }

                public Segment() {}
                
                public Segment(byte[] data) : base() {
            this.FromByteArray(data);
                }

                public Segment(SegmentHeaders headers, SegmentData data) {
                        this.headers = headers;
                        this.data = data;
                        // TODO: Add more Segment constructor logic.
                }

                public byte[] ToByteArray(){
                        byte[] result = new byte[headers.Length + data.Length];
                        headers.ToByteArray().CopyTo(result, 0);
                        data.ToByteArray().CopyTo(result, headers.Length);
                        return result;
                }

                public void FromByteArray(byte[] src) {
                        int index = 0;
                        headers = new SegmentHeaders();
                        data = new SegmentData();

                        headers.FromByteArray(ref src, ref index);
                        data.FromByteArray(ref src, ref index);
                }

        }

        public class SegmentDataTooBig : Exception {}

        public class SegmentData {
                private byte[] data;
                public static readonly int MAX_DATA_SIZE = 471; 
                // was 476 before adding in the 2 byte size field.
                // 01/04/2002 Removed another 3 when I increased the size of the headers

                public SegmentData() {}

                public SegmentData(byte[] data) {
                        Data = data;
                }

                public byte[] Data {
                        get { return data; }
                        set { if (value.Length <= MAX_DATA_SIZE) {
                                          data = value; } 
                                  else {
                                          throw new SegmentDataTooBig();
                                  }
                        }
                }

                public ushort DataLength {
                        get { if (data != null) {
                                          return (ushort)data.Length;
                                  } else {
                                          return 0;
                                  }
                        }
                }

                public ushort Length {
                        get {  return (ushort)(DataLength + 2); } // the 1st 2 bytes is the data size.
                }

                public byte[] ToByteArray() {
                        byte[] result = new byte[Length]; 
                        BitConverter.GetBytes(DataLength).CopyTo(result, 0);
                        Data.CopyTo(result, 2);
                        return result;
                }

                public void FromByteArray(ref byte[] src, ref int currentPos) {
                        int tempLength;
                        tempLength = BitConverter.ToUInt16(src, currentPos); 
                        currentPos += 2;
                        Data = new byte[tempLength];
                        for (int i = 0; i < tempLength; i++, currentPos++) {
                                Data[i] = src[currentPos];
                        }
                }

                public void Test() {
                        Data = new byte[] {1,2,3,4,5,6,7,8,9,10};
                }

                public static SegmentData[] FromMessage(Message msg) {
                        return FromMessage(msg, MAX_DATA_SIZE);
                }

                public static SegmentData[] FromMessage(Message msg, int maxDataSize) {
                        SegmentData[] result;
                        int segmentCount = 0; 
                        long copyLength = 0;
                        uint currentPos = 0;
                        byte[] segmentDataBuffer = Message.SerialiseMessage(msg);

                        segmentCount = (int)(Math.Ceiling((double)segmentDataBuffer.Length / maxDataSize));
                        result = new SegmentData[segmentCount];
                        for (int i = 0; i < segmentCount; i++) {
                                result[i] = new SegmentData();
                                // if what we have to put in, minus what we have put in already, is bigger than a segment
                                if ((segmentDataBuffer.Length - currentPos) > maxDataSize) {
                                        copyLength = maxDataSize; }// then we're copying a whole segment
                                else { // we're copying a bit of a segment - could be out by one or two here.
                                        copyLength = segmentDataBuffer.Length - currentPos;
                                }
                                result[i].Data = new byte[copyLength];
                                Array.Copy(segmentDataBuffer, (int)currentPos, result[i].Data, 0, (int)copyLength);
                                currentPos += (uint)copyLength;
                        }
                        return result;
                }
                public static byte[] ArrayToByteArray(SegmentData[] src) {
                        // concatenate segments into huge byte array
                        int numSegments = src.Length;
                        int byteCount = 0;
                        int bufferPtr = 0;
                        byte[] buffer;
                        // (crude but effective)
                        for (int i = 0; i < numSegments; i++) {
                                byteCount += src[i].DataLength; // TODO: (4) Make this nicer
                        }
                        buffer = new byte[byteCount - 1]; // correct for 1st type byte, we don't need that
                                
                        // copy into the huge buffer
                        for (int i = 0; i < numSegments; i++) {
                                // note correction for 1st segment data bit as type entry
                                Array.Copy(src[i].Data, (i == 0) ? 1 : 0, buffer, bufferPtr, (i == 0) ? src[i].DataLength - 1 : src[i].DataLength);
                                bufferPtr += src[i].DataLength - ((i == 0) ? 1 : 0); // data Length is actaully data Length -1 for 1st segment
                        }
                        return buffer;
                }
        }

        public class SegmentHeaders {
                SegmentFlags flags;
                // some list of segment headers
                uint synchOrRate; // 32 but synchronisation or rate information
                ushort srcDeviceID; // 16 bit device ID of source
                bool isRetransmission;

                uint sequenceNumber; // 32 bit segment sequence number
                DateTime sent; // filled in just before Tx.
                DateTime received; // only used when the segment arrives at Rx

                uint ACK_SequenceNumberACKd; // 32 bit Sequence number of segment to ACK

                uint NACK_SequenceNumberNACKd; // 32 bit seq number of segment to NACK
                uint NACK_Range; // 32 bits. Number of segments after the one specify to consider NACK'd too
                
                public SegmentHeaders() {
                        flags = new SegmentFlags();
                }

                public bool IsRetransmission {
                        get { return isRetransmission; }
                        set { isRetransmission = value; }
                }

                public DateTime TimeSent {
                        get { return sent; }
                        set { sent = value; }
                }

                public DateTime TimeReceived {
                        get { return received; }
                        set { received = value; }
                
                }

                public int Length {
                        get {
                                int runningTotal = 0; // how many bytes are there so far...
                                runningTotal += flags.Length; // add the flags at the start
                                // sizeOf synchOrRate
                                runningTotal += BitConverter.GetBytes(synchOrRate).Length;
                                // sizeOf Src Device ID
                                runningTotal += BitConverter.GetBytes(srcDeviceID).Length;
                                // sizeOf SegmentNumber
                                runningTotal += BitConverter.GetBytes(sequenceNumber).Length;
                                // sizeOf Send Timestamp
                                runningTotal += BitConverter.GetBytes(sent.Ticks).Length;

                                // we don't care that it's ackable - that's not our concern right now.
                                if (flags.isACK) { // if it's an ACK, then it will have the segment number of the segment it's ACKing
                                        runningTotal += BitConverter.GetBytes(ACK_SequenceNumberACKd).Length; 
                                }
                                if (flags.isNACK) { // NACK headers
                                        runningTotal += BitConverter.GetBytes(NACK_SequenceNumberNACKd).Length;
                                        if (flags.isRangedNACK) {
                                                runningTotal += BitConverter.GetBytes(NACK_Range).Length;
                                        }
                                }
                                return runningTotal;
                        }
                }

                public byte[] ToByteArray() {
                        byte[] result = new byte[Length];
                        byte[] buffer;
                        int currentPos = 0;
                        buffer = flags.ToByteArray();
                        buffer.CopyTo(result, currentPos);
                        currentPos += buffer.Length;

                        buffer = BitConverter.GetBytes(synchOrRate);
                        buffer.CopyTo(result, currentPos);
                        currentPos += buffer.Length; 

                        buffer = BitConverter.GetBytes(srcDeviceID);
                        buffer.CopyTo(result, currentPos);
                        currentPos += buffer.Length;

                        buffer = BitConverter.GetBytes(sequenceNumber);
                        buffer.CopyTo(result, currentPos);
                        currentPos += buffer.Length;

                        buffer = BitConverter.GetBytes(sent.Ticks);
                        buffer.CopyTo(result, currentPos);
                        currentPos += buffer.Length;

                        if (flags.isACK) {
                                buffer = BitConverter.GetBytes(ACK_SequenceNumberACKd);
                                buffer.CopyTo(result, currentPos);
                                currentPos += buffer.Length;
                        }

                        if (flags.isNACK) {
                                buffer = BitConverter.GetBytes(NACK_SequenceNumberNACKd);
                                buffer.CopyTo(result, currentPos);
                                currentPos += buffer.Length;
                                if (flags.isRangedNACK) {
                                        buffer = BitConverter.GetBytes(NACK_Range);
                                        buffer.CopyTo(result, currentPos);
                                        currentPos += buffer.Length;
                                }
                        }
                        return result;
                }

                public void FromByteArray(ref byte[] src, ref int currentPos) {
                        flags = new SegmentFlags();
                        flags.FromByte(src[currentPos]); // construct flags
                        currentPos += 1;

                        synchOrRate = BitConverter.ToUInt32(src, currentPos); // construct Sychronisation Offset / Rate Info
                        currentPos += 4;

                        srcDeviceID = BitConverter.ToUInt16(src, currentPos);
                        currentPos += 2;

                        sequenceNumber = BitConverter.ToUInt32(src, currentPos);
                        currentPos += 4;

                        sent = new DateTime(BitConverter.ToInt64(src, currentPos));
                        currentPos += 8;

                        if (flags.isACK) {
                                ACK_SequenceNumberACKd = BitConverter.ToUInt32(src, currentPos);
                                currentPos += 4;
                        }

                        if (flags.isNACK) {
                                NACK_SequenceNumberNACKd = BitConverter.ToUInt32(src, currentPos);
                                currentPos += 4;
                                if (flags.isRangedNACK) {
                                        NACK_Range = BitConverter.ToUInt32(src, currentPos);
                                        currentPos += 4;
                                }
                        }
                }


                public void SetNACKStatus(NackInfo nackInfo) {
                        flags.isNACK = true;
                        NACK_SequenceNumberNACKd = nackInfo.SequenceNumber;
                        flags.isRangedNACK = nackInfo.IsRanged;
                        NACK_Range = (nackInfo.IsRanged ? nackInfo.Range : 0);
                }

                public void ClearNACKStatus() {
                        flags.isNACK = false;
                        NACK_SequenceNumberNACKd = 0;
                        flags.isRangedNACK = false;
                        NACK_Range = 0;
                }
                
                public void SetAck(AckInfo ackInfo) {
                        flags.isACK = true;
                        ACK_SequenceNumberACKd = ackInfo.SequenceNumber;
                }

                public void ClearAck() {
                        flags.isACK = false;
                        ACK_SequenceNumberACKd = 0;
                }

                public bool IsAckable {
                        get { return flags.isACKable; }
                        set { flags.isACKable = value; }
                }

                public bool IsAck {
                        get { return flags.isACK; }
                }

                public uint ACKdSequenceNumber {
                        // TODO: Throw exception if flags.isAck is false?
                        get { return ACK_SequenceNumberACKd; }
                }
                
                public bool IsResynch {
                        get { return flags.isSynchedPacket; }
                        set { flags.isSynchedPacket = value; }
                }

                public bool IsFirstInMessage {
                        get { return flags.isFirstMessageSegment; }
                        set { flags.isFirstMessageSegment= value; }
                }
                public bool IsLastInMessage {
                        get { return flags.isLastMessageSegment; }
                        set { flags.isLastMessageSegment = value; }
                }

                public ushort SourceDeviceID {
                        get { return srcDeviceID; }
                        set { srcDeviceID = value; }
                }

                public uint SequenceNumber {
                        get {return sequenceNumber; }
                        set {sequenceNumber = value; }
                }

                public uint SynchOrRate {
                        get { return synchOrRate; }
                        set { synchOrRate = value; }

                }

                public bool IsNACK {
                        get { return flags.isNACK; }

                }

                public bool IsRangedNACK {
                        get { return flags.isRangedNACK; }
                }

                public NackInfo NackInfo {
                        get { return new NackInfo(NACK_SequenceNumberNACKd, NACK_Range); }
                }

                public void Test() {
                        flags = new SegmentFlags();
                        flags.Test();
                        srcDeviceID = 1234;
                        sequenceNumber = 2;
                        NACK_Range = 42;
                        NACK_SequenceNumberNACKd = 314159;
                        ACK_SequenceNumberACKd = 76;
                        sent = DateTime.Now;
                }


        }

        public class SegmentFlags {
                public int Length {
                        get { return 1; }
                } 

                // TODO: Convert these into properties
                public bool isACK;
                public bool isACKable;
                public bool isNACK;
                public bool isRangedNACK;
                public bool isSynchedPacket; 
                /* or 'isNotRateData'. The SynchOffset 8 bit field has 2 purposes:
                 * It is either the offset from 1st packet of new timestamp'd segemnt
                 * or is rate control information, depending on the value of this bit. A zero 
                 * in rate control info indicaes no change.*/
                public bool isFirstMessageSegment;
                public bool isLastMessageSegment;


                public byte[] ToByteArray() {
                        byte temp = 0;
                        temp += (byte)(isACK ? 1 : 0);
                        temp += (byte)(isACKable ? 1 << 1 : 0);
                        temp += (byte)(isNACK ? 1 << 2 : 0);
                        temp += (byte)(isRangedNACK ? 1 << 3: 0);
                        temp += (byte)(isSynchedPacket ? 1 << 4: 0);
                        temp += (byte)(isFirstMessageSegment ? 1 << 5: 0);
                        temp += (byte)(isLastMessageSegment ? 1 << 6: 0);
                        temp += (byte)(false ? 1 << 7: 0); // for future expansion.
                        return new byte[] {temp};
                }

                public void FromByteArray(byte[] src) {
                        this.FromByte(src[0]);
                }

                public void FromByte(byte src) {
                        isACK = ((src & (1 << 0)) != 0);
                        isACKable = ((src & (1 << 1)) != 0);
                        isNACK = ((src & (1 << 2)) != 0);
                        isRangedNACK = ((src & (1 << 3)) != 0);
                        isSynchedPacket = ((src & (1 << 4)) != 0);
                        isFirstMessageSegment = ((src & (1 << 5)) != 0);
                        isLastMessageSegment = ((src & (1 << 6)) != 0);
                }

                public void Test() {
                        isACK = true;
                        isACKable = true;
                        isNACK = true;
                        isRangedNACK = true;
                        isSynchedPacket = false;
                        isFirstMessageSegment = false;
                        isLastMessageSegment = false;
                }
        }


}

---