puma.h

组播路由协议

            meshMember_                = false;
            neighborConfirmationWait_  = false;
            partitionConfirmationWait_ = false;
            delayedMAPending_          = false;

            lastSequenceNumber_        = 0;
            coreId_                    = coreId;
            lastMAReceived_            = NEVER;
            lastMAOriginated_          = NEVER;
            connectivityList_          = new ConnectivityList();
            
            nextItem_                  = NULL;
        }

        ~MulticastGroup() {
            delete connectivityList_;
        }
        
        inline nsaddr_t&     multicastAddress()     {return multicastAddress_;}
        inline bool&         receiver()             {return receiver_;}
        inline bool&         meshMember()           {return meshMember_;}
        inline bool&         neighborConfirmationWait() 
                                             {return neighborConfirmationWait_;}
        inline bool&         partitionConfirmationWait()
                                            {return partitionConfirmationWait_;}
        inline bool&         delayedMAPending()     {return delayedMAPending_;}

        inline unsigned int& lastSequenceNumber()  {return lastSequenceNumber_;}
        inline nsaddr_t&     coreId()               {return coreId_;}
        inline double&       lastMAReceived()       {return lastMAReceived_;}
        inline double&       lastMAOriginated()     {return lastMAOriginated_;}

        bool reset();
};

class MulticastGroups {
public:
        MulticastGroup* start_;

        MulticastGroups() {
            start_ = NULL;
        }
        
        ~MulticastGroups() {
            MulticastGroup* temp;
            while (start_ != NULL) {
                temp = start_->nextItem_;
                delete start_;
                start_ = temp;
            }
        }

        void            append(MulticastGroup*);
        MulticastGroup* find(nsaddr_t);
        int             getNumberOfGroups();
};

/*
 * Multicast Announcement
 */
struct MulticastAnnouncement {
        nsaddr_t        multicastAddress_;
        nsaddr_t        coreId_;
        nsaddr_t        nextHop_;
        unsigned short  distanceToCore_;
        unsigned int    sequenceNumber_;
        bool            meshMember_;
};

/*
 * ACK Table
 */
class ACKTableItem {
protected:
        double   timeHeard_;
        nsaddr_t heardFrom_;
public:
        ACKTableItem() {
            timeHeard_ = NEVER;
            heardFrom_ = INVALID_ADDRESS;
        }

        ACKTableItem(double newTimeHeard, nsaddr_t newHeardFrom) {
            timeHeard_ = newTimeHeard;
            heardFrom_ = newHeardFrom;
        }
        
        inline double&   timeHeard() {return timeHeard_;}
        inline nsaddr_t& heardFrom() {return heardFrom_;}
};

class ACKTable {
protected:
        int          numberOfACKTableEntries_;
        int          nextEmptySlotInACKTable_;
public:
        ACKTableItem ACKTableData_[NUMBER_OF_ACK_TABLE_ENTRIES];

        ACKTable() {
            numberOfACKTableEntries_ = 0;
            nextEmptySlotInACKTable_ = 0;
        }

        inline int&  numberOfACKTableEntries() {return numberOfACKTableEntries_;}
        inline int&  nextEmptySlotInACKTable() {return nextEmptySlotInACKTable_;}

        void          removeObsoleteEntries();
        int           getFirstOccupiedSlot();
        ACKTableItem elementAt(short);
};

struct ACKTimeoutMessage {
        nsaddr_t multicastAddress_;
        nsaddr_t nextHop_;
};

class RoutingEvent : public Event {
protected:
        short eventType_;
public:
        void* data_;

        RoutingEvent(short newEventType, void* newData) : Event() {
                eventType_ = newEventType;
                data_ = newData;
        }

        inline short eventType() {return eventType_;}
};

/*
 * Routing Timer
 */
class RoutingTimer : public Handler {
protected:
        PUMA*       agent_;
        virtual void handle(Event*);

public:
        RoutingTimer(PUMA* agent) : Handler() {
            agent_ = agent;
        }
};

/*
 * PUMA
 */
class PUMA : public Agent {
        // As well known, timers are our friends.
        friend class RoutingTimer;

protected:
        nsaddr_t           id_;                   // Address of this node
        MessageCache       messageCache_;         // To discard double packets
        MulticastGroups    multicastGroups_;      // Multicast groups table
        unsigned int       packetSequenceNumber_; // Packet sequence number
        double             lastPacketReceived_;
        
        PortClassifier*    dmux_;                 // Pass packets up to agents
        Trace*             logTarget_;            // For logging

        RoutingTimer*      routingTimer_;
        
        ACKTable           ackTable_;
        
        RNG                random_;

        void     handleProtocolPacket(Packet*);
        void     handleDataFromTransport(Packet*);

        void     resetMATimer(double);
        void     resetBucketTimer(double);
        void     handleMA(MulticastGroup*, MulticastAnnouncement, nsaddr_t);
        void     sendNextMA(MulticastGroup*);
        void     sendASingleMA(MulticastGroup*);
        void     sendAGenericMA(MulticastGroup*, int, nsaddr_t);
        void     handleBucket(Packet*);
        void     handleDataPacketFromNetwork(Packet*);
        void     acceptDataPacket(Packet*);
        void     processMulticastPacket(Packet*);
        void     bookKeepingBeforeMA(MulticastGroup*);
        void     forwardFreshDataPacket(MulticastGroup*, Packet*);
        void     sendNextBucket();
        void     handleJoinFromTransport(nsaddr_t);
        void     handlePartitionConfirmationRequest(MulticastGroup*, nsaddr_t, 
                                                    unsigned int);
        void     handleFresherMA(MulticastGroup* group,MulticastAnnouncement ma, 
                                 nsaddr_t source);
        void     handleLeaveFromTransport(nsaddr_t);
        void     fightElection(MulticastGroup*);
        void     fightMultipleGroupElectionAfterPartition(MulticastGroup*);
        void     recordACK(nsaddr_t);
        void     sendAPartitionConfirmationRequest(MulticastGroup*);
        void     becomeCore(MulticastGroup*);
        void     becomeReceiver(MulticastGroup*);
        void     becomeCoreAfterPartition(MulticastGroup*);
        void     setRetransmissionTimer(nsaddr_t, short, double, nsaddr_t);
        void     sendADelayedMA(MulticastGroup*);
        void     updateGroup(MulticastGroup*, MulticastAnnouncement, 
                                 nsaddr_t);
        void     handleProtocolEvent(Event*);
        bool     shouldISendMA(MulticastGroup*);
        bool     isSingleGroupPresent();
        bool     doIForwardThisPacket(MulticastGroup*, Packet*);
        bool     isPartitionFlagSet(MulticastGroup*);
        bool     amIMeshMember(MulticastGroup*);
        bool     amILinkNode(MulticastGroup*);
        bool     wasACKReceived(nsaddr_t);
        int      getNumberOfMeshChildren(ConnectivityListItem*);
        int      distanceToCore(MulticastGroup*);
        nsaddr_t getNextHop(MulticastGroup*);

public:
         PUMA(nsaddr_t newId) : Agent(PT_PUMA), messageCache_(this) {
             id_                   = newId;
             packetSequenceNumber_ = 0;
             lastPacketReceived_   = NEVER;
             logTarget_            = NULL;
             routingTimer_         = new RoutingTimer(this);
             random_.set_seed((long)0);
             routingSetTimer(SEND_NEXT_BUCKET, NULL, 
                             random_.uniform(1.0) * MULTICAST_ANNOUNCEMENT);
         }

        int      command(int, const char*const*);
        void     recv(Packet*, Handler*);
        void     routingSetTimer(short, void*, double);
};
#endif /*PUMA_H_*/