puma.h

组播路由协议

/* Copyright (c) 2007 Sidney Doria
 * Federal University of Campina Grande
 * Brazil
 * 
 * This file is part of PUMA.
 * 
 *    PUMA is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published
 *    by the Free Software Foundation; either version 2 of the License,
 *    or(at your option) any later version.
 * 
 *    PUMA is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with PUMA; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 
 *    02110-1301 USA
 */
#ifndef PUMA_H_
#define PUMA_H_

#include <classifier-port.h>
#include <agent.h>
#include <ip.h>
#include <packet.h>
#include <timer-handler.h>
#include <address.h>
#include <rng.h>
#include <cmu-trace.h>
#include <trace.h>

#include "puma_pkt.h"

#define NOW                             Scheduler::instance().clock()
#define NEVER                                  -1
#define INVALID_ADDRESS                 987654321
#define ALL_SHORTEST_PATHS                  false
#define PARTITION                               0
#define NORMAL                                  1
#define NUMBER_OF_PARENTS                       5
#define NUMBER_OF_ACK_TABLE_ENTRIES            30
#define MAX_HOP                                50
#define INVALID_DISTANCE                    65535
#define TENTATIVE_PARTITION             987654320

#define SEND_NEXT_MA                           11
#define SEND_NEXT_BUCKET                       21
#define FLUSH_TABLES                           31
#define SEND_PENDING_MA                        41
#define JOIN_ACK_TIMEOUT                       51
#define DATA_ACK_TIMEOUT                       61
#define PARTITION_ACK_TIMEOUT                  71

#define BROADCAST_JITTER                        0.010 //  10 milliseconds
#define ACK_TIMEOUT_INTERVAL                    0.040 //  40 milliseconds
#define MULTICAST_ANNOUNCEMENT_DELAY            0.150 // 150 milliseconds
#define PARTITION_ACK_TIMEOUT_INTERVAL          1.000 //   1 second
#define MULTICAST_ANNOUNCEMENT                  3.000 //   3 seconds
#define FLUSH_INTERVAL                      36000.000 // 600 minutes

class PUMA;

/*
 * Message Cache
 */
class MessageCacheItem {
protected:
        nsaddr_t          source_;
        int               sequenceNumber_;
        
public:
        MessageCacheItem* nextItem_;

        MessageCacheItem() {
            source_         = INVALID_ADDRESS;
            sequenceNumber_ = 0;
            nextItem_       = NULL;
        }
        
        MessageCacheItem(nsaddr_t newSource, int newSequenceNumber) {
            source_         = newSource;
            sequenceNumber_ = newSequenceNumber;
            nextItem_       = NULL;
        }
        
        inline nsaddr_t&          source()         {return source_;}
        inline int&               sequenceNumber() {return sequenceNumber_;}

        bool isEqualTo(MessageCacheItem*);
};

class MessageCache {
protected:
        int               size_;
        
public:
        PUMA*            agent_;

        MessageCacheItem* front_;
        MessageCacheItem* rear_;

        MessageCache(PUMA* agent) {
            front_ = NULL;
            rear_  = NULL;
            size_  = 0;
            agent_ = agent;
        }
        
        ~MessageCache() {
            MessageCacheItem* temp;
            while (front_ != NULL) {
                temp = front_->nextItem_;
                delete front_;
                front_ = temp;
            }
        }
        
        inline int&               size()  {return size_;}
        
        void append(MessageCacheItem*);
        void removeFront();
        bool find(MessageCacheItem*);
};

/*
 * Connectivity List
 */
class ConnectivityListItem {
protected:
        nsaddr_t              nextHop_;
        nsaddr_t              nextHopsNextHop_;
        unsigned short int    distanceToCore_;
        unsigned int          sequenceNumber_;
        double                lastMAReceived_;
        bool                  meshMember_;
        
public:
        ConnectivityListItem* nextItem_;

        ConnectivityListItem(nsaddr_t newNextHop, 
                             unsigned short int newDistanceToCore, 
                             unsigned int newSequenceNumber, 
                             nsaddr_t newNextHopsNextHop, bool newMeshMember) {
            nextHop_         = newNextHop;
            nextHopsNextHop_ = newNextHopsNextHop;
            distanceToCore_  = newDistanceToCore;
            sequenceNumber_  = newSequenceNumber;
            lastMAReceived_  = NOW;
            meshMember_      = newMeshMember;

            nextItem_        = NULL;
        }

        inline nsaddr_t&           nextHop()         {return nextHop_;}
        inline nsaddr_t&           nextHopsNextHop() {return nextHopsNextHop_;}
        inline unsigned short int& distanceToCore()  {return distanceToCore_;}
        inline unsigned int&       sequenceNumber()  {return sequenceNumber_;}
        inline double&             lastMAReceived()  {return lastMAReceived_;}
        inline bool&               meshMember()      {return meshMember_;}
        
        bool isEqualTo(ConnectivityListItem*);
        bool isBetterThan(ConnectivityListItem*);
};

class ConnectivityList {
public:
        ConnectivityListItem* start_;

        ConnectivityList() {
            start_ = NULL;
        }
        
        ~ConnectivityList() {
            ConnectivityListItem* temp;
            while (start_ != NULL) {
                temp = start_->nextItem_;
               delete start_;
                start_ = temp;
            }
        }
        
        void addSorted(ConnectivityListItem*);
        void remove(ConnectivityListItem*);
};

/*
 * Multicast Groups
 */
class MulticastGroup {
protected:
        // Core independent attributes. Don't change if core changes.
        nsaddr_t          multicastAddress_;
        bool              receiver_;
        bool              meshMember_;
        bool              neighborConfirmationWait_;
        bool              partitionConfirmationWait_;
        bool              delayedMAPending_;
        // Core dependent attributes. Set to default if core changes.
        unsigned int      lastSequenceNumber_;
        nsaddr_t          coreId_;
        double            lastMAReceived_;
        double            lastMAOriginated_;

public:
        ConnectivityList* connectivityList_;
        
        MulticastGroup*   nextItem_;

        MulticastGroup() {
            multicastAddress_          = INVALID_ADDRESS;
            receiver_                  = false;
            meshMember_                = false;
            neighborConfirmationWait_  = false;
            partitionConfirmationWait_ = false;
            delayedMAPending_          = false;

            lastSequenceNumber_        = 0;
            coreId_                    = INVALID_ADDRESS;
            lastMAReceived_            = NEVER;
            lastMAOriginated_          = NEVER;
            connectivityList_          = new ConnectivityList();
            
            nextItem_                  = NULL;
        }
        
        MulticastGroup(nsaddr_t newMulticastAddress, nsaddr_t coreId) {
            multicastAddress_          = newMulticastAddress;
            receiver_                  = false;