ProtocolStack/SequenceManager.cs

using System;
using System.Collections.Specialized;

namespace ProtocolStack
{
        public class SequenceManager
        {
                private uint nextInSendSequence; // next number to send
                private uint expectedNextInReceiveSequence; // next number to receive

                private bool nextInSequenceUnknown; // is the next receive number known?
                private uint sendSequenceRoot = 0; // root of the current sent sequequence numbers
                private uint receiveSequenceRoot = 0; // root of the current received sequence numbers

                private DateTime earliestMissing; // the timestamp of segment we got before we missed one.
                private DateTime lastSeen; // the timestamp of the segment last received

                private int resynchCount = 0; // number of segments remaining before resynch complete

                private MissingList missingList; // list of missing segments
                private NACKManager nackManager; // the NACK manager that will issue NACKs

                public SequenceManager(NACKManager nackManager) {
                        Console.WriteLine("Creating Sequence Manager...");
                        StartResynch(); // resets resynch counters
                        missingList = new MissingList();
                        earliestMissing = DateTime.MinValue; // init
                        lastSeen = DateTime.MinValue; // init
                        nextInSequenceUnknown = true;
                        this.nackManager = nackManager;
                        //TODO: Set up initial send sequence and do re-synch code if need be
                        Console.WriteLine("... Sequence Manager Created");
                }
                
                uint LastSeenNumber {
                        get {return expectedNextInReceiveSequence - 1 /* mod stuff, changeover stuff */;}
                }

                public bool IsSegmentsMissing {
                        get { return missingList.AreSegmentsMissing; } 
                }




                public void ResetConnection() {
                        Console.WriteLine("Resetting Sequence Manager...");
                        StartResynch(); // reset the connection number
                        missingList.Clear();
                        earliestMissing = DateTime.MinValue;
                        lastSeen = DateTime.MinValue;
                        nextInSequenceUnknown = true;
                        Console.WriteLine("... Sequence Manager Reset");
                }

                public uint GetNextSequenceNumber() {
                        uint sequenceNumber;
                        /* Should loop round and round and round. 
                         * On new sequence number, should start talking about resynch numbers */
                        sequenceNumber = nextInSendSequence;
                        nextInSendSequence = (uint)(((long)nextInSendSequence + 1L) % UInt32.MaxValue);
                        return sequenceNumber;
                }

                private void StartResynch() {
                        Random r = new Random();
                        nextInSendSequence = (uint)r.Next(1000,9999);
                        sendSequenceRoot = nextInSendSequence;
                        resynchCount = 3;
                }

                public bool IsResynching {
                        get { return (resynchCount != 0); }
                }

                public uint GetSequenceOffset(uint number) {
                        /* returns the number of packets difference between 
                         * the sequence number passed to it, and the start of that sequence*/
                        resynchCount--;
                        return (uint)(number - sendSequenceRoot); // TODO: Correct for rollover
                }

                public void ProcessReceivedSegmentHeaders(ref SegmentHeaders headers) {
                        long numberOfMissingSegments = 0;
                        /* Deal with ReSynchronisation issues
                         * update expectedNextInReceiveSequence 
                         * update list of missing segments (add / remove entries)
                         * cutoff timestamps, last seen timestamps, etc?
                         * call NACK services if need be?
                         * */
                        if (nextInSequenceUnknown) {
                                Console.WriteLine("    Next sequence # unknown, adopting #" + headers.SequenceNumber + " as next expected.");
                                receiveSequenceRoot = headers.SequenceNumber;
                                expectedNextInReceiveSequence = headers.SequenceNumber;
                                // TODO: May need to reset buffers, etc...
                                nextInSequenceUnknown = false;
                        } else if (headers.IsResynch && !headers.IsRetransmission) {
                                if (receiveSequenceRoot != headers.SequenceNumber - headers.SynchOrRate) {
                                        receiveSequenceRoot = (headers.SequenceNumber - headers.SynchOrRate); // TODO: Correct for wrapround
                                        Console.WriteLine("    Resynch Detected. Adopting #" + receiveSequenceRoot + " as root of new sequence");
                                        expectedNextInReceiveSequence = headers.SequenceNumber ; // TODO: Figure out how we can generate the right number of NACKs if we need to
                                        Console.WriteLine("    Checking for missing segments at start of sequence");
                                        for (uint i = receiveSequenceRoot; i < headers.SequenceNumber; i++) {
                                                Console.WriteLine("SeqManager: Mismatch between new sequence root and new segment. Issuing NACK");
                                                nackManager.IssueNACK(i);
                                                missingList.Add(i, lastSeen);
                                                earliestMissing = missingList.GetEarliestMissingTime();
                                        }
                                        Console.WriteLine("    New sequence init complete");
                                }
                        }
                        // We know that the segment has a timestamp greater than the one last seen, or is definitely on the missing list.
                        // What does it mean if the segment has the most recent timestamp, but a smaller sequence number than we've already seen? 
                        // Answer - rollover. That's OK.
                
                        // first, if the segment that arrived fills a gap?
                        if (missingList.IsMissing(headers.SequenceNumber)) {
                                missingList.Remove(headers.SequenceNumber); // remove it 
                                earliestMissing = missingList.GetEarliestMissingTime(); // update the earliest missing thing.
                                if (earliestMissing == DateTime.MaxValue) { // Sentinal Value
                                        earliestMissing = lastSeen; // a reasonable value
                                }
                        }   // do not update last received timestamp
                                // do not update next expected sequence number
                        else { // was not missing. See if it causes missing ones....
                                if (headers.SequenceNumber != expectedNextInReceiveSequence) { // Something's gone missing
                                        numberOfMissingSegments = (long)headers.SequenceNumber - (long)expectedNextInReceiveSequence;
                                        if (numberOfMissingSegments == 1) {     
                                                nackManager.IssueNACK(expectedNextInReceiveSequence); 
                                                missingList.Add(expectedNextInReceiveSequence, lastSeen);
                                        }
                                        else { 
                                                nackManager.IssueNACK(expectedNextInReceiveSequence, numberOfMissingSegments); 
                                                for (int i = 0; i < numberOfMissingSegments; i++) {
                                                        missingList.Add((uint)(expectedNextInReceiveSequence + i), lastSeen);
                                                }
                                        }
                                        //Console.WriteLine(missingList.AsArray);
                                        earliestMissing = missingList.GetEarliestMissingTime(); // update the earliest missing thing.
                                } // in both NACK issuing and non-nack issuing cases, we need to update some variables
                                expectedNextInReceiveSequence = (uint)(((ulong)headers.SequenceNumber + 1L) % UInt32.MaxValue); // longs to prevent overflow
                                // TODO: Fix for overflow?
                                lastSeen = headers.TimeSent;
                        } 
                        //Console.WriteLine("Seq Manager: Process Received Segment Headers.... Done");
                }

                public bool IsProcessable(SegmentHeaders headers) {
                        bool result = true;
                        if (headers.TimeSent < earliestMissing) { 
                                result = false; 
                        }
                        // all segments now >= earliestMissing
                        else if (headers.TimeSent == lastSeen) { // does it have same timestamp as the last seen segment?
                                if (headers.SequenceNumber == LastSeenNumber) { result = false; } // discard - is a duplicate
                                else if ((headers.SequenceNumber < LastSeenNumber) && (!missingList.IsMissing(headers.SequenceNumber))) { result = false; } // is a duplucate
                        }
                        // all segments now sent != last Seen time
                        else if (headers.TimeSent < lastSeen) { // is it now a duplicate, or a late segment?
                                if (!missingList.IsMissing(headers.SequenceNumber)) { result = false; } // not missing => duplicate
                        }
                        // all segments either now > last seen time, and thus processable, or <= last seen time,
                        // > cutoff time, and are on missing list

                        /**** HACK HACK HACK ****/
                        if (headers.IsRetransmission)
                                result = true; // always process retransmissions (for now)
                        /**** END HACK ****/
                        return result;
                }

        }

        class MissingList : HybridDictionary {
                public bool IsMissing(uint target) {
                        return Contains(target);
                }

                public void Remove(uint sequenceNumber) {
                        base.Remove(sequenceNumber);
                }

                public void Add(uint sequenceNumber, DateTime lastSeen) {
                        base.Add(sequenceNumber, lastSeen);
                } 

                public DateTime GetEarliestMissingTime() {
                        DateTime result = DateTime.MaxValue; 
                        DateTime[] listValues = new DateTime[Values.Count];
                        this.Values.CopyTo(listValues, 0);
                        foreach (DateTime dt in listValues) {
                                if (dt < result) { result = dt; }
                        }
                        return result;
                }

                public bool AreSegmentsMissing {
                        get { return (Count != 0); }
                }

        }
}

---