ISIStypes.h

Go to the documentation of this file.

// Author: Matej Hrncirik
// FIT VUT 2012
//
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see http://www.gnu.org/licenses/.
//

#ifndef ISISTYPES_H_
#define ISISTYPES_H_

#include "MACAddress.h"
#include "InterfaceEntry.h"
#include "ISISTimer_m.h"
#include "ISISMessage_m.h"
//#include "ISIS.h"


#define ISIS_DIS_PRIORITY 64 
#define ISIS_METRIC 10 
#define ISIS_HELLO_INTERVAL 10 
#define ISIS_HELLO_MULTIPLIER 3 
#define ISIS_SYSTEM_ID 6 
#define ISIS_MAX_AREAS 3 
#define ISIS_AREA_ID 3 
#define ISIS_LSP_INTERVAL 33 
#define ISIS_LSP_REFRESH_INTERVAL 150 
#define ISIS_LSP_MAX_LIFETIME 200 
#define ISIS_LSP_GEN_INTERVAL 5 
#define ISIS_LSP_INIT_WAIT 50 
#define ISIS_CSNP_INTERVAL 10 
#define ISIS_PSNP_INTERVAL 2 
#define ISIS_LSP_MAX_SIZE 1492  //TODO change to something smaller so we can test it
#define ISIS_LSP_SEND_INTERVAL 5 
#define ISIS_SPF_FULL_INTERVAL 50
//class InterfaceEntr;
//class MACAddress;

struct ISISinterface
{
    int intID;                
    int gateIndex;            
    bool network;             
    //bool broadcast;         /*!<broadcast enabled?*/
    //bool loopback;          /*!<is it loopback?*/
    bool passive;             
    bool ISISenabled;         
    short circuitType;        
    unsigned char priority;   
    unsigned char L1DISpriority;    
    unsigned char L2DISpriority;    
    unsigned char L1DIS[7];   
    unsigned char L2DIS[7];   
    unsigned char metric;     
    int L1HelloInterval;                        
    int L2HelloInterval;                        
    short L1HelloMultiplier;                    
    short L2HelloMultiplier;                    
    int lspInterval;                            
    int L1CsnpInterval;                           
    int L2CsnpInterval;                           
    int L1PsnpInterval;                           
    int L2PsnpInterval;                           
    InterfaceEntry *entry;    
};

struct ISISadj
{
    unsigned char sysID[6];             
    unsigned char areaID[3];            
    MACAddress mac;                     
    bool state;                         
    ISISTimer *timer;                   
    int gateIndex;                      
    bool network;                       
    //bool operator for sorting
    bool operator<(const ISISadj& adj2) const {

        for (unsigned int j = 0; j < ISIS_AREA_ID; j++){
            if(areaID[j] < adj2.areaID[j]){
                return true; //first is smaller, so return true
            }else if(areaID[j] > adj2.areaID[j]){
                return false; //first is bigger, so return false
            }
            //if it's equal then continue to next one
        }
        //AreaIDs match, so compare system IDs

        for (unsigned int i = 0; i < ISIS_SYSTEM_ID; i++){
            if(sysID[i] < adj2.sysID[i]){
                return true; //first is smaller, so return true
            }else if(sysID[i] > adj2.sysID[i]){
                return false; //first is bigger, so return false
            }
            //if it's equal then continue to next one
        }

        //if the first MAC address is smaller, return true
        if(mac.compareTo(adj2.mac) < 0){
            return true;
        }

        //if they're equal, return false
        return false;
    }
};

struct metrics_t
{
    unsigned char defaultMetric;  
    unsigned char delayMetric;    
    unsigned char expenseMetric;  
    unsigned char errortMetric;   
};

struct LSPneighbour
{
    unsigned char LANid[7]; 
    metrics_t metrics;      
};

struct LSPrecord
{
    std::vector<LSPneighbour> neighbours;    //list of neighbours
    unsigned char LSPid[8];             //ID of LSP
    unsigned long seq;                  //sequence number
    ISISTimer *deadTimer;               //dead timer - 1200s
};

struct LSPRecord
{
        ISISLSPPacket* LSP; //link-state protocol data unit
        ISISTimer *deadTimer; //dead timer
        std::vector<bool> SRMflags;
        std::vector<bool> SSNflags;
        double simLifetime; 
/*        LSPRecord(){
            for (std::vector<ISISinterface>::iterator intIt = this->ISISIft.begin(); intIt != this->ISISIft.end(); ++intIt)
            {

                this->SRMflags.push_back(false);
                this->SSNflags.push_back(false);

            }
        }*/

        ~LSPRecord(){

/*            for (unsigned int i = 0; i < this->LSP->getTLVArraySize(); i++)
            {
                if(this->LSP->getTLV(i).value != NULL){
                    delete this->LSP->getTLV(i).value;
                }
            }*/
            this->LSP->setTLVArraySize(0);
            if(this->LSP != NULL){
                delete this->LSP;
            }
//            if(this->deadTimer != NULL){
//                drop(this->deadTimer);
//                delete this->deadTimer;
//            }
            this->SRMflags.clear();
            this->SSNflags.clear();
        }

        //bool operator for sorting
         bool operator<(const LSPRecord& lspRec2) const {

             for (unsigned int i = 0; i < ISIS_SYSTEM_ID + 2; i++){
                 if(this->LSP->getLspID(i) < lspRec2.LSP->getLspID(i)){
                     return true; //first is smaller, so return true
                 }else if(this->LSP->getLspID(i) > lspRec2.LSP->getLspID(i)){
                     return false; //first is bigger, so return false
                 }
                 //if it's equal then continue to next one
             }

             //if they're equal, return false
             return false;
         }

};
typedef std::vector<LSPRecord *> LSPRecQ_t;

struct FlagRecord
{
        LSPRecord *lspRec;
        int index;
        //destructor!!
        ~FlagRecord(){

        }
};
typedef std::vector<FlagRecord*> FlagRecQ_t;
typedef std::vector<std::vector<FlagRecord*> *> FlagRecQQ_t;
struct ISISNeighbour
{
        unsigned char *id;
        //uint32_t metric;
        bool type; //should represent whether it's a leaf node; true = leaf


};

typedef std::vector<ISISNeighbour*> ISISNeighbours_t;

struct ISISPath
{
        unsigned char *to;
        uint32_t metric;
        ISISNeighbours_t from;
        //bool operator for sorting
         bool operator<(const ISISPath& path2) const {

             for (unsigned int i = 0; i < ISIS_SYSTEM_ID + 2; i++){
                 if(this->metric < path2.metric){
                     return true; //first is smaller, so return true
                 }else{
                     return false; //first is bigger, so return false
                 }
                 //if it's equal then continue to next one
             }

             //if they're equal, return false
             return false;
         }
};

typedef std::vector<ISISPath*> ISISPaths_t;
typedef std::vector<LSPRecord *> ISISLspDb_t;

struct ISISCon
{
        unsigned char *from;
        unsigned char *to;
        uint32_t metric;
        bool type;
};
typedef std::vector<ISISCon*> ISISCons_t;

/*
 * Adjacency states for 3-way handshake on point-to-point links
 */
enum PTP_HELLO_ADJ_STATE
{
    PTP_UP = 1,
    PTP_INIT = 2,
    PTP_DOWN = 3
};



#endif /* ISISTYPES_H_ */