INET Framework for OMNeT++/OMNEST
Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes | Friends
AnsaOSPF::Interface Class Reference

#include <AnsaOSPFInterface.h>

List of all members.

Public Types

enum  InterfaceEventType {
  InterfaceUp = 0, HelloTimer = 1, WaitTimer = 2, AcknowledgementTimer = 3,
  BackupSeen = 4, NeighborChange = 5, LoopIndication = 6, UnloopIndication = 7,
  InterfaceDown = 8
}
enum  OSPFInterfaceType {
  UnknownType = 0, PointToPoint = 1, Broadcast = 2, NBMA = 3,
  PointToMultiPoint = 4, Virtual = 5
}
enum  InterfaceStateType {
  DownState = 0, LoopbackState = 1, WaitingState = 2, PointToPointState = 3,
  NotDesignatedRouterState = 4, BackupState = 5, DesignatedRouterState = 6
}

Public Member Functions

 Interface (OSPFInterfaceType ifType=UnknownType)
virtual ~Interface (void)
void ProcessEvent (InterfaceEventType event)
void Reset (void)
void SendHelloPacket (IPv4Address destination, short ttl=1)
void SendLSAcknowledgement (OSPFLSAHeader *lsaHeader, IPv4Address destination)
Neighbor * GetNeighborByID (RouterID neighborID)
Neighbor * GetNeighborByAddress (IPv4Address address)
void AddNeighbor (Neighbor *neighbor)
InterfaceStateType GetState (void) const
bool HasAnyNeighborInStates (int states) const
void RemoveFromAllRetransmissionLists (LSAKeyType lsaKey)
bool IsOnAnyRetransmissionList (LSAKeyType lsaKey) const
bool FloodLSA (OSPFLSA *lsa, Interface *intf=NULL, Neighbor *neighbor=NULL)
void AddDelayedAcknowledgement (OSPFLSAHeader &lsaHeader)
void SendDelayedAcknowledgements (void)
void AgeTransmittedLSALists (void)
OSPFLinkStateUpdatePacket * CreateUpdatePacket (OSPFLSA *lsa)
void SetType (OSPFInterfaceType ifType)
OSPFInterfaceType GetType (void) const
void SetIfIndex (unsigned char index)
unsigned char GetIfIndex (void) const
void SetMTU (unsigned short ifMTU)
unsigned short GetMTU (void) const
void SetAreaID (AreaID areaId)
AreaID GetAreaID (void) const
void SetTransitAreaID (AreaID areaId)
AreaID GetTransitAreaID (void) const
void SetOutputCost (Metric cost)
Metric GetOutputCost (void) const
void SetRetransmissionInterval (short interval)
short GetRetransmissionInterval (void) const
void SetTransmissionDelay (short delay)
short GetTransmissionDelay (void) const
void SetAcknowledgementDelay (short delay)
short GetAcknowledgementDelay (void) const
void SetRouterPriority (unsigned char priority)
unsigned char GetRouterPriority (void) const
void SetHelloInterval (short interval)
short GetHelloInterval (void) const
void SetPollInterval (short interval)
short GetPollInterval (void) const
void SetRouterDeadInterval (short interval)
short GetRouterDeadInterval (void) const
void SetAuthenticationType (AuthenticationType type)
AuthenticationType GetAuthenticationType (void) const
void SetAuthenticationKey (AuthenticationKeyType key)
AuthenticationKeyType GetAuthenticationKey (void) const
void SetAddressRange (IPv4AddressRange range)
IPv4AddressRange GetAddressRange (void) const
OSPFTimer * GetHelloTimer (void)
OSPFTimer * GetWaitTimer (void)
OSPFTimer * GetAcknowledgementTimer (void)
DesignatedRouterID GetDesignatedRouter (void) const
DesignatedRouterID GetBackupDesignatedRouter (void) const
unsigned long GetNeighborCount (void) const
Neighbor * GetNeighbor (unsigned long i)
const Neighbor * GetNeighbor (unsigned long i) const
void SetArea (Area *area)
Area * GetArea (void)
const Area * GetArea (void) const
bool IsGoingDown (void)
void SetIsGoingDown (bool b)

Static Public Member Functions

static const char * GetStateString (InterfaceStateType stateType)

Private Member Functions

void ChangeState (InterfaceState *newState, InterfaceState *currentState)

Private Attributes

OSPFInterfaceType interfaceType
InterfaceState * state
InterfaceState * previousState
unsigned char ifIndex
unsigned short mtu
IPv4AddressRange interfaceAddressRange
AreaID areaID
AreaID transitAreaID
short helloInterval
short pollInterval
short routerDeadInterval
short interfaceTransmissionDelay
unsigned char routerPriority
OSPFTimer * helloTimer
OSPFTimer * waitTimer
OSPFTimer * acknowledgementTimer
std::map< RouterID, Neighbor * > neighboringRoutersByID
std::map< IPv4Address,
Neighbor *, IPv4Address_Less > 		neighboringRoutersByAddress
std::vector< Neighbor * > neighboringRouters
std::map< IPv4Address,
std::list< OSPFLSAHeader >
, IPv4Address_Less > 		delayedAcknowledgements
DesignatedRouterID designatedRouter
DesignatedRouterID backupDesignatedRouter
Metric interfaceOutputCost
short retransmissionInterval
short acknowledgementDelay
AuthenticationType authenticationType
AuthenticationKeyType authenticationKey
Area * parentArea
bool isGoingDown

Friends

class InterfaceState

Detailed Description

Definition at line 17 of file AnsaOSPFInterface.h.

Member Enumeration Documentation

enum AnsaOSPF::Interface::InterfaceEventType
Enumerator:
InterfaceUp 
HelloTimer 
WaitTimer 
AcknowledgementTimer 
BackupSeen 
NeighborChange 
LoopIndication 
UnloopIndication 
InterfaceDown 

Definition at line 19 of file AnsaOSPFInterface.h.

                            {
        InterfaceUp          = 0,
        HelloTimer           = 1,
        WaitTimer            = 2,
        AcknowledgementTimer = 3,
        BackupSeen           = 4,
        NeighborChange       = 5,
        LoopIndication       = 6,
        UnloopIndication     = 7,
        InterfaceDown        = 8
    };
enum AnsaOSPF::Interface::InterfaceStateType
Enumerator:
DownState 
LoopbackState 
WaitingState 
PointToPointState 
NotDesignatedRouterState 
BackupState 
DesignatedRouterState 

Definition at line 40 of file AnsaOSPFInterface.h.

                            {
        DownState                = 0,
        LoopbackState            = 1,
        WaitingState             = 2,
        PointToPointState        = 3,
        NotDesignatedRouterState = 4,
        BackupState              = 5,
        DesignatedRouterState    = 6
    };
enum AnsaOSPF::Interface::OSPFInterfaceType
Enumerator:
UnknownType 
PointToPoint 
Broadcast 
NBMA 
PointToMultiPoint 
Virtual 

Definition at line 31 of file AnsaOSPFInterface.h.

                           {
        UnknownType       = 0,
        PointToPoint      = 1,
        Broadcast         = 2,
        NBMA              = 3,
        PointToMultiPoint = 4,
        Virtual           = 5
    };

Constructor & Destructor Documentation

AnsaOSPF::Interface::Interface ( OSPFInterfaceType  ifType = UnknownType)

Definition at line 11 of file AnsaOSPFInterface.cc.

                                                                      :
    interfaceType(ifType),
    ifIndex(0),
    mtu(0),
    interfaceAddressRange(AnsaOSPF::NullIPv4AddressRange),
    areaID(AnsaOSPF::BackboneAreaID),
    transitAreaID(AnsaOSPF::BackboneAreaID),
    helloInterval(10),
    pollInterval(120),
    routerDeadInterval(40),
    interfaceTransmissionDelay(1),
    routerPriority(1),
    designatedRouter(AnsaOSPF::NullDesignatedRouterID),
    backupDesignatedRouter(AnsaOSPF::NullDesignatedRouterID),
    interfaceOutputCost(1),
    retransmissionInterval(5),
    acknowledgementDelay(1),
    authenticationType(AnsaOSPF::NullType),
    parentArea(NULL),
    isGoingDown(false)
{
    state = new AnsaOSPF::InterfaceStateDown;
    previousState = NULL;
    helloTimer = new OSPFTimer;
    helloTimer->setTimerKind(InterfaceHelloTimer);
    helloTimer->setContextPointer(this);
    helloTimer->setName("AnsaOSPF::Interface::InterfaceHelloTimer");
    waitTimer = new OSPFTimer;
    waitTimer->setTimerKind(InterfaceWaitTimer);
    waitTimer->setContextPointer(this);
    waitTimer->setName("AnsaOSPF::Interface::InterfaceWaitTimer");
    acknowledgementTimer = new OSPFTimer;
    acknowledgementTimer->setTimerKind(InterfaceAcknowledgementTimer);
    acknowledgementTimer->setContextPointer(this);
    acknowledgementTimer->setName("AnsaOSPF::Interface::InterfaceAcknowledgementTimer");
    memset(authenticationKey.bytes, 0, 8 * sizeof(char));
}
AnsaOSPF::Interface::~Interface ( void  ) [virtual]

Definition at line 49 of file AnsaOSPFInterface.cc.

{
    MessageHandler* messageHandler = parentArea->GetRouter()->GetMessageHandler();
    messageHandler->ClearTimer(helloTimer);
    delete helloTimer;
    messageHandler->ClearTimer(waitTimer);
    delete waitTimer;
    messageHandler->ClearTimer(acknowledgementTimer);
    delete acknowledgementTimer;
    if (previousState != NULL) {
        delete previousState;
    }
    delete state;
    long neighborCount = neighboringRouters.size();
    for (long i = 0; i < neighborCount; i++) {
        delete neighboringRouters[i];
    }
}

Member Function Documentation

void AnsaOSPF::Interface::AddDelayedAcknowledgement ( OSPFLSAHeader &  lsaHeader)

Definition at line 479 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA().

{
    if (interfaceType == AnsaOSPF::Interface::Broadcast) {
        if ((GetState() == AnsaOSPF::Interface::DesignatedRouterState) ||
            (GetState() == AnsaOSPF::Interface::BackupState) ||
            (designatedRouter == AnsaOSPF::NullDesignatedRouterID))
        {
            delayedAcknowledgements[AnsaOSPF::AllSPFRouters].push_back(lsaHeader);
        } else {
            delayedAcknowledgements[AnsaOSPF::AllDRouters].push_back(lsaHeader);
        }
    } else {
        long neighborCount = neighboringRouters.size();
        for (long i = 0; i < neighborCount; i++) {
            if (neighboringRouters[i]->GetState() >= AnsaOSPF::Neighbor::ExchangeState) {
                delayedAcknowledgements[neighboringRouters[i]->GetAddress()].push_back(lsaHeader);
            }
        }
    }
}
void AnsaOSPF::Interface::AddNeighbor ( AnsaOSPF::Neighbor *  neighbor)

Definition at line 200 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPFRouting::LoadInterfaceParameters(), AnsaOSPFRouting::LoadVirtualLink(), and AnsaOSPF::HelloHandler::ProcessPacket().

{
    neighboringRoutersByID[neighbor->GetNeighborID()] = neighbor;
    neighboringRoutersByAddress[neighbor->GetAddress()] = neighbor;
    neighbor->SetInterface(this);
    neighboringRouters.push_back(neighbor);
}
void AnsaOSPF::Interface::AgeTransmittedLSALists ( void  )

Definition at line 558 of file AnsaOSPFInterface.cc.

{
    long neighborCount = neighboringRouters.size();
    for (long i = 0; i < neighborCount; i++) {
        neighboringRouters[i]->AgeTransmittedLSAList();
    }
}
void AnsaOSPF::Interface::ChangeState ( AnsaOSPF::InterfaceState *  newState,
AnsaOSPF::InterfaceState *  currentState 
) [private]

Definition at line 79 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::InterfaceState::ChangeState().

{
    if (previousState != NULL) {
        delete previousState;
    }
    state = newState;
    previousState = currentState;
}
OSPFLinkStateUpdatePacket * AnsaOSPF::Interface::CreateUpdatePacket ( OSPFLSA *  lsa)

Definition at line 392 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::LinkStateRequestHandler::ProcessPacket(), and AnsaOSPF::LinkStateUpdateHandler::ProcessPacket().

{
    LSAType lsaType                  = static_cast<LSAType> (lsa->getHeader().getLsType());
    OSPFRouterLSA* routerLSA         = (lsaType == RouterLSAType) ? dynamic_cast<OSPFRouterLSA*> (lsa) : NULL;
    OSPFNetworkLSA* networkLSA       = (lsaType == NetworkLSAType) ? dynamic_cast<OSPFNetworkLSA*> (lsa) : NULL;
    OSPFSummaryLSA* summaryLSA       = ((lsaType == SummaryLSA_NetworksType) ||
                                        (lsaType == SummaryLSA_ASBoundaryRoutersType)) ? dynamic_cast<OSPFSummaryLSA*> (lsa) : NULL;
    OSPFASExternalLSA* asExternalLSA = (lsaType == ASExternalLSAType) ? dynamic_cast<OSPFASExternalLSA*> (lsa) : NULL;

    if (((lsaType == RouterLSAType) && (routerLSA != NULL)) ||
        ((lsaType == NetworkLSAType) && (networkLSA != NULL)) ||
        (((lsaType == SummaryLSA_NetworksType) || (lsaType == SummaryLSA_ASBoundaryRoutersType)) && (summaryLSA != NULL)) ||
        ((lsaType == ASExternalLSAType) && (asExternalLSA != NULL)))
    {
        OSPFLinkStateUpdatePacket* updatePacket = new OSPFLinkStateUpdatePacket;

        updatePacket->setType(LinkStateUpdatePacket);
        updatePacket->setRouterID(parentArea->GetRouter()->GetRouterID());
        updatePacket->setAreaID(areaID);
        updatePacket->setAuthenticationType(authenticationType);
        for (int j = 0; j < 8; j++) {
            updatePacket->setAuthentication(j, authenticationKey.bytes[j]);
        }

        updatePacket->setNumberOfLSAs(1);

        switch (lsaType) {
            case RouterLSAType:
                {
                    updatePacket->setRouterLSAsArraySize(1);
                    updatePacket->setRouterLSAs(0, *routerLSA);
                    unsigned short lsAge = updatePacket->getRouterLSAs(0).getHeader().getLsAge();
                    if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
                        updatePacket->getRouterLSAs(0).getHeader().setLsAge(lsAge + interfaceTransmissionDelay);
                    } else {
                        updatePacket->getRouterLSAs(0).getHeader().setLsAge(MAX_AGE);
                    }
                }
                break;
            case NetworkLSAType:
                {
                    updatePacket->setNetworkLSAsArraySize(1);
                    updatePacket->setNetworkLSAs(0, *networkLSA);
                    unsigned short lsAge = updatePacket->getNetworkLSAs(0).getHeader().getLsAge();
                    if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
                        updatePacket->getNetworkLSAs(0).getHeader().setLsAge(lsAge + interfaceTransmissionDelay);
                    } else {
                        updatePacket->getNetworkLSAs(0).getHeader().setLsAge(MAX_AGE);
                    }
                }
                break;
            case SummaryLSA_NetworksType:
            case SummaryLSA_ASBoundaryRoutersType:
                {
                    updatePacket->setSummaryLSAsArraySize(1);
                    updatePacket->setSummaryLSAs(0, *summaryLSA);
                    unsigned short lsAge = updatePacket->getSummaryLSAs(0).getHeader().getLsAge();
                    if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
                        updatePacket->getSummaryLSAs(0).getHeader().setLsAge(lsAge + interfaceTransmissionDelay);
                    } else {
                        updatePacket->getSummaryLSAs(0).getHeader().setLsAge(MAX_AGE);
                    }
                }
                break;
            case ASExternalLSAType:
                {
                    updatePacket->setAsExternalLSAsArraySize(1);
                    updatePacket->setAsExternalLSAs(0, *asExternalLSA);
                    unsigned short lsAge = updatePacket->getAsExternalLSAs(0).getHeader().getLsAge();
                    if (lsAge < MAX_AGE - interfaceTransmissionDelay) {
                        updatePacket->getAsExternalLSAs(0).getHeader().setLsAge(lsAge + interfaceTransmissionDelay);
                    } else {
                        updatePacket->getAsExternalLSAs(0).getHeader().setLsAge(MAX_AGE);
                    }
                }
                break;
            default: break;
        }

        updatePacket->setPacketLength(0); // TODO: Calculate correct length
        updatePacket->setChecksum(0); // TODO: Calculate correct cheksum(16-bit one's complement of the entire packet)

        return updatePacket;
    }
    return NULL;
}
bool AnsaOSPF::Interface::FloodLSA ( OSPFLSA *  lsa,
AnsaOSPF::Interface *  intf = NULL,
AnsaOSPF::Neighbor *  neighbor = NULL 
)
See also:
RFC2328 Section 13.3.

Definition at line 262 of file AnsaOSPFInterface.cc.

{
    bool floodedBackOut = false;

    if (
        (
         (lsa->getHeader().getLsType() == ASExternalLSAType) &&
         (interfaceType != AnsaOSPF::Interface::Virtual) &&
         (parentArea->GetExternalRoutingCapability())
        ) ||
        (
         (lsa->getHeader().getLsType() != ASExternalLSAType) &&
         (
          (
           (areaID != AnsaOSPF::BackboneAreaID) &&
           (interfaceType != AnsaOSPF::Interface::Virtual)
          ) ||
          (areaID == AnsaOSPF::BackboneAreaID)
         )
        )
       )
    {
        long              neighborCount                = neighboringRouters.size();
        bool              lsaAddedToRetransmissionList = false;
        AnsaOSPF::LinkStateID linkStateID                  = lsa->getHeader().getLinkStateID();
        AnsaOSPF::LSAKeyType  lsaKey;

        lsaKey.linkStateID = linkStateID;
        lsaKey.advertisingRouter = lsa->getHeader().getAdvertisingRouter().getInt();

        for (long i = 0; i < neighborCount; i++) {  // (1)
            if (neighboringRouters[i]->GetState() < AnsaOSPF::Neighbor::ExchangeState) {   // (1) (a)
                continue;
            }
            if (neighboringRouters[i]->GetState() < AnsaOSPF::Neighbor::FullState) {   // (1) (b)
                OSPFLSAHeader* requestLSAHeader = neighboringRouters[i]->FindOnRequestList(lsaKey);
                if (requestLSAHeader != NULL) {
                    // operator< and operator== on OSPFLSAHeaders determines which one is newer(less means older)
                    if (lsa->getHeader() < (*requestLSAHeader)) {
                        continue;
                    }
                    if (operator== (lsa->getHeader(), (*requestLSAHeader))) {
                        neighboringRouters[i]->RemoveFromRequestList(lsaKey);
                        continue;
                    }
                    neighboringRouters[i]->RemoveFromRequestList(lsaKey);
                }
            }
            if (neighbor == neighboringRouters[i]) {     // (1) (c)
                continue;
            }
            neighboringRouters[i]->AddToRetransmissionList(lsa);   // (1) (d)
            lsaAddedToRetransmissionList = true;
        }
        if (lsaAddedToRetransmissionList) {     // (2)
            if ((intf != this) ||
                ((neighbor != NULL) &&
                 (neighbor->GetNeighborID() != designatedRouter.routerID) &&
                 (neighbor->GetNeighborID() != backupDesignatedRouter.routerID)))  // (3)
            {
                if ((intf != this) || (GetState() != AnsaOSPF::Interface::BackupState)) {  // (4)
                    OSPFLinkStateUpdatePacket* updatePacket = CreateUpdatePacket(lsa);    // (5)

                    if (updatePacket != NULL) {
                        int                   ttl            = (interfaceType == AnsaOSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1;
                        AnsaOSPF::MessageHandler* messageHandler = parentArea->GetRouter()->GetMessageHandler();

                        if (interfaceType == AnsaOSPF::Interface::Broadcast) {
                            if ((GetState() == AnsaOSPF::Interface::DesignatedRouterState) ||
                                (GetState() == AnsaOSPF::Interface::BackupState) ||
                                (designatedRouter == AnsaOSPF::NullDesignatedRouterID))
                            {
                                messageHandler->SendPacket(updatePacket, AnsaOSPF::AllSPFRouters, ifIndex, ttl);
                                for (long k = 0; k < neighborCount; k++) {
                                    neighboringRouters[k]->AddToTransmittedLSAList(lsaKey);
                                    if (!neighboringRouters[k]->IsUpdateRetransmissionTimerActive()) {
                                        neighboringRouters[k]->StartUpdateRetransmissionTimer();
                                    }
                                }
                            } else {
                                messageHandler->SendPacket(updatePacket, AnsaOSPF::AllDRouters, ifIndex, ttl);
                                AnsaOSPF::Neighbor* dRouter = GetNeighborByID(designatedRouter.routerID);
                                AnsaOSPF::Neighbor* backupDRouter = GetNeighborByID(backupDesignatedRouter.routerID);
                                if (dRouter != NULL) {
                                    dRouter->AddToTransmittedLSAList(lsaKey);
                                    if (!dRouter->IsUpdateRetransmissionTimerActive()) {
                                        dRouter->StartUpdateRetransmissionTimer();
                                    }
                                }
                                if (backupDRouter != NULL) {
                                    backupDRouter->AddToTransmittedLSAList(lsaKey);
                                    if (!backupDRouter->IsUpdateRetransmissionTimerActive()) {
                                        backupDRouter->StartUpdateRetransmissionTimer();
                                    }
                                }
                            }
                        } else {
                            if (interfaceType == AnsaOSPF::Interface::PointToPoint) {
                                messageHandler->SendPacket(updatePacket, AnsaOSPF::AllSPFRouters, ifIndex, ttl);
                                if (neighborCount > 0) {
                                    neighboringRouters[0]->AddToTransmittedLSAList(lsaKey);
                                    if (!neighboringRouters[0]->IsUpdateRetransmissionTimerActive()) {
                                        neighboringRouters[0]->StartUpdateRetransmissionTimer();
                                    }
                                }
                            } else {
                                for (long m = 0; m < neighborCount; m++) {
                                    if (neighboringRouters[m]->GetState() >= AnsaOSPF::Neighbor::ExchangeState) {
                                        messageHandler->SendPacket(updatePacket, neighboringRouters[m]->GetAddress(), ifIndex, ttl);
                                        neighboringRouters[m]->AddToTransmittedLSAList(lsaKey);
                                        if (!neighboringRouters[m]->IsUpdateRetransmissionTimerActive()) {
                                            neighboringRouters[m]->StartUpdateRetransmissionTimer();
                                        }
                                    }
                                }
                            }
                        }

                        if (intf == this) {
                            floodedBackOut = true;
                        }
                    }
                }
            }
        }
    }

    return floodedBackOut;
}
short AnsaOSPF::Interface::GetAcknowledgementDelay ( void  ) const [inline]

Definition at line 126 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateDown::ProcessEvent().

{ return acknowledgementDelay; }
OSPFTimer* AnsaOSPF::Interface::GetAcknowledgementTimer ( void  ) [inline]

Definition at line 144 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateDown::ProcessEvent().

{ return acknowledgementTimer; }
IPv4AddressRange AnsaOSPF::Interface::GetAddressRange ( void  ) const [inline]

Definition at line 140 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceState::ChangeState(), AnsaOSPF::NeighborState::ChangeState(), AnsaOSPF::Area::OriginateNetworkLSA(), AnsaOSPF::Area::OriginateRouterLSA(), and AnsaOSPF::HelloHandler::ProcessPacket().

{ return interfaceAddressRange; }
Area* AnsaOSPF::Interface::GetArea ( void  ) [inline]

Definition at line 152 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA(), AnsaOSPF::InterfaceState::ChangeState(), AnsaOSPF::NeighborState::ChangeState(), AnsaOSPF::DatabaseDescriptionHandler::ProcessDDPacket(), AnsaOSPF::NeighborStateFull::ProcessEvent(), AnsaOSPF::NeighborStateInit::ProcessEvent(), AnsaOSPF::NeighborStateExchange::ProcessEvent(), AnsaOSPF::NeighborStateDown::ProcessEvent(), AnsaOSPF::NeighborStateAttempt::ProcessEvent(), AnsaOSPF::InterfaceStateDown::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::NeighborStateExchangeStart::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::NeighborStateTwoWay::ProcessEvent(), AnsaOSPF::NeighborStateLoading::ProcessEvent(), AnsaOSPF::LinkStateRequestHandler::ProcessPacket(), and AnsaOSPF::HelloHandler::ProcessPacket().

{ return parentArea; }
const Area* AnsaOSPF::Interface::GetArea ( void  ) const [inline]

Definition at line 153 of file AnsaOSPFInterface.h.

{ return parentArea; }
AreaID AnsaOSPF::Interface::GetAreaID ( void  ) const [inline]

Definition at line 116 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::LoadVirtualLink().

{ return areaID; }
AuthenticationKeyType AnsaOSPF::Interface::GetAuthenticationKey ( void  ) const [inline]

Definition at line 138 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA().

{ return authenticationKey; }
AuthenticationType AnsaOSPF::Interface::GetAuthenticationType ( void  ) const [inline]

Definition at line 136 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA().

{ return authenticationType; }
DesignatedRouterID AnsaOSPF::Interface::GetBackupDesignatedRouter ( void  ) const [inline]

Definition at line 146 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent().

{ return backupDesignatedRouter; }
DesignatedRouterID AnsaOSPF::Interface::GetDesignatedRouter ( void  ) const [inline]

Definition at line 145 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA(), AnsaOSPF::Area::OriginateRouterLSA(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::LinkStateRequestHandler::ProcessPacket(), and AnsaOSPF::LinkStateUpdateHandler::ProcessPacket().

{ return designatedRouter; }
short AnsaOSPF::Interface::GetHelloInterval ( void  ) const [inline]

Definition at line 130 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent(), and AnsaOSPF::HelloHandler::ProcessPacket().

{ return helloInterval; }
OSPFTimer* AnsaOSPF::Interface::GetHelloTimer ( void  ) [inline]

Definition at line 142 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateDown::ProcessEvent(), and AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent().

{ return helloTimer; }
unsigned char AnsaOSPF::Interface::GetIfIndex ( void  ) const [inline]

Definition at line 112 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA(), AnsaOSPF::Area::OriginateRouterLSA(), AnsaOSPF::MessageHandler::PrintEvent(), AnsaOSPF::LinkStateRequestHandler::ProcessPacket(), and AnsaOSPF::LinkStateUpdateHandler::ProcessPacket().

{ return ifIndex; }
unsigned short AnsaOSPF::Interface::GetMTU ( void  ) const [inline]

Definition at line 114 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::DatabaseDescriptionHandler::ProcessPacket().

{ return mtu; }
Neighbor* AnsaOSPF::Interface::GetNeighbor ( unsigned long  i) [inline]

Definition at line 148 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::Area::OriginateNetworkLSA(), AnsaOSPF::Area::OriginateRouterLSA(), AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateDown::ProcessEvent(), AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), and AnsaOSPF::HelloHandler::ProcessPacket().

{ return neighboringRouters[i]; }
const Neighbor* AnsaOSPF::Interface::GetNeighbor ( unsigned long  i) const [inline]

Definition at line 149 of file AnsaOSPFInterface.h.

{ return neighboringRouters[i]; }
AnsaOSPF::Neighbor * AnsaOSPF::Interface::GetNeighborByAddress ( AnsaOSPF::IPv4Address  address)

Definition at line 189 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::Area::OriginateRouterLSA(), AnsaOSPF::HelloHandler::ProcessPacket(), and AnsaOSPF::MessageHandler::ProcessPacket().

{
    std::map<AnsaOSPF::IPv4Address, AnsaOSPF::Neighbor*, AnsaOSPF::IPv4Address_Less>::iterator neighborIt = neighboringRoutersByAddress.find(address);
    if (neighborIt != neighboringRoutersByAddress.end()) {
        return (neighborIt->second);
    }
    else {
        return NULL;
    }
}
AnsaOSPF::Neighbor * AnsaOSPF::Interface::GetNeighborByID ( AnsaOSPF::RouterID  neighborID)

Definition at line 178 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA(), AnsaOSPF::HelloHandler::ProcessPacket(), and AnsaOSPF::MessageHandler::ProcessPacket().

{
    std::map<AnsaOSPF::RouterID, AnsaOSPF::Neighbor*>::iterator neighborIt = neighboringRoutersByID.find(neighborID);
    if (neighborIt != neighboringRoutersByID.end()) {
        return (neighborIt->second);
    }
    else {
        return NULL;
    }
}
unsigned long AnsaOSPF::Interface::GetNeighborCount ( void  ) const [inline]

Definition at line 147 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::Area::AgeDatabase(), AnsaOSPF::Area::OriginateNetworkLSA(), AnsaOSPF::Area::OriginateRouterLSA(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::InterfaceStateDown::ProcessEvent(), AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), and AnsaOSPF::HelloHandler::ProcessPacket().

{ return neighboringRouters.size(); }
Metric AnsaOSPF::Interface::GetOutputCost ( void  ) const [inline]

Definition at line 120 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::Area::OriginateRouterLSA().

{ return interfaceOutputCost; }
short AnsaOSPF::Interface::GetPollInterval ( void  ) const [inline]

Definition at line 132 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::NeighborStateAttempt::ProcessEvent(), AnsaOSPF::NeighborStateTwoWay::ProcessEvent(), AnsaOSPF::NeighborStateLoading::ProcessEvent(), AnsaOSPF::NeighborStateInit::ProcessEvent(), AnsaOSPF::NeighborStateFull::ProcessEvent(), AnsaOSPF::NeighborStateExchangeStart::ProcessEvent(), AnsaOSPF::NeighborStateExchange::ProcessEvent(), and AnsaOSPF::NeighborStateDown::ProcessEvent().

{ return pollInterval; }
short AnsaOSPF::Interface::GetRetransmissionInterval ( void  ) const [inline]

Definition at line 122 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::NeighborStateExchange::ProcessEvent(), AnsaOSPF::NeighborStateTwoWay::ProcessEvent(), AnsaOSPF::NeighborStateLoading::ProcessEvent(), AnsaOSPF::NeighborStateInit::ProcessEvent(), AnsaOSPF::NeighborStateFull::ProcessEvent(), and AnsaOSPF::NeighborStateExchangeStart::ProcessEvent().

{ return retransmissionInterval; }
short AnsaOSPF::Interface::GetRouterDeadInterval ( void  ) const [inline]

Definition at line 134 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateDown::ProcessEvent(), and AnsaOSPF::HelloHandler::ProcessPacket().

{ return routerDeadInterval; }
unsigned char AnsaOSPF::Interface::GetRouterPriority ( void  ) const [inline]

Definition at line 128 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateDown::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), and AnsaOSPF::HelloHandler::ProcessPacket().

{ return routerPriority; }
AnsaOSPF::Interface::InterfaceStateType AnsaOSPF::Interface::GetState ( void  ) const

Definition at line 208 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA(), AnsaOSPF::Area::AgeDatabase(), AnsaOSPF::InterfaceState::CalculateDesignatedRouter(), AnsaOSPF::NeighborState::ChangeState(), AnsaOSPF::Area::OriginateRouterLSA(), AnsaOSPF::MessageHandler::PrintEvent(), AnsaOSPF::HelloHandler::ProcessPacket(), AnsaOSPF::LinkStateRequestHandler::ProcessPacket(), AnsaOSPF::LinkStateUpdateHandler::ProcessPacket(), and AnsaOSPF::MessageHandler::ProcessPacket().

{
    return state->GetState();
}
const char * AnsaOSPF::Interface::GetStateString ( InterfaceStateType  stateType) [static]

Definition at line 213 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::MessageHandler::PrintEvent().

{
    switch (stateType) {
        case DownState:                 return "Down";
        case LoopbackState:             return "Loopback";
        case WaitingState:              return "Waiting";
        case PointToPointState:         return "PointToPoint";
        case NotDesignatedRouterState:  return "NotDesignatedRouter";
        case BackupState:               return "Backup";
        case DesignatedRouterState:     return "DesignatedRouter";
        default:                        ASSERT(false);
    }
    return "";
}
AreaID AnsaOSPF::Interface::GetTransitAreaID ( void  ) const [inline]

Definition at line 118 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::MessageHandler::ProcessPacket().

{ return transitAreaID; }
short AnsaOSPF::Interface::GetTransmissionDelay ( void  ) const [inline]

Definition at line 124 of file AnsaOSPFInterface.h.

{ return interfaceTransmissionDelay; }
OSPFInterfaceType AnsaOSPF::Interface::GetType ( void  ) const [inline]

Definition at line 110 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::LinkStateUpdateHandler::AcknowledgeLSA(), AnsaOSPFRouting::AnsaLoadInterface(), AnsaOSPF::InterfaceState::ChangeState(), AnsaOSPF::Area::OriginateRouterLSA(), AnsaOSPF::MessageHandler::PrintEvent(), AnsaOSPF::NeighborStateFull::ProcessEvent(), AnsaOSPF::NeighborStateTwoWay::ProcessEvent(), AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::NeighborStateDown::ProcessEvent(), AnsaOSPF::NeighborStateAttempt::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::NeighborStateExchange::ProcessEvent(), AnsaOSPF::NeighborStateExchangeStart::ProcessEvent(), AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateDown::ProcessEvent(), AnsaOSPF::NeighborStateInit::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::NeighborStateLoading::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::LinkStateRequestHandler::ProcessPacket(), AnsaOSPF::HelloHandler::ProcessPacket(), AnsaOSPF::LinkStateUpdateHandler::ProcessPacket(), and AnsaOSPF::MessageHandler::ProcessPacket().

{ return interfaceType; }
OSPFTimer* AnsaOSPF::Interface::GetWaitTimer ( void  ) [inline]

Definition at line 143 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateDown::ProcessEvent().

{ return waitTimer; }
bool AnsaOSPF::Interface::HasAnyNeighborInStates ( int  states) const

Definition at line 228 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::Area::AgeDatabase(), AnsaOSPF::Area::OriginateNetworkLSA(), and AnsaOSPF::Area::OriginateRouterLSA().

{
    long neighborCount = neighboringRouters.size();
    for (long i = 0; i < neighborCount; i++) {
        AnsaOSPF::Neighbor::NeighborStateType neighborState = neighboringRouters[i]->GetState();
        if (neighborState & states) {
            return true;
        }
    }
    return false;
}
bool AnsaOSPF::Interface::IsGoingDown ( void  ) [inline]

Definition at line 155 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::NeighborState::ChangeState().

{ return isGoingDown; }
bool AnsaOSPF::Interface::IsOnAnyRetransmissionList ( AnsaOSPF::LSAKeyType  lsaKey) const

Definition at line 248 of file AnsaOSPFInterface.cc.

{
    long neighborCount = neighboringRouters.size();
    for (long i = 0; i < neighborCount; i++) {
        if (neighboringRouters[i]->IsLSAOnRetransmissionList(lsaKey)) {
            return true;
        }
    }
    return false;
}
void AnsaOSPF::Interface::ProcessEvent ( InterfaceEventType  event)

Definition at line 88 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPFRouting::AnsaLoadConfigFromXML(), AnsaOSPF::MessageHandler::HandleTimer(), AnsaOSPFRouting::LoadInterfaceParameters(), and AnsaOSPF::HelloHandler::ProcessPacket().

{
    state->ProcessEvent(this, event);
}
void AnsaOSPF::Interface::RemoveFromAllRetransmissionLists ( AnsaOSPF::LSAKeyType  lsaKey)

Definition at line 240 of file AnsaOSPFInterface.cc.

{
    long neighborCount = neighboringRouters.size();
    for (long i = 0; i < neighborCount; i++) {
        neighboringRouters[i]->RemoveFromRetransmissionList(lsaKey);
    }
}
void AnsaOSPF::Interface::Reset ( void  )

Definition at line 93 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateLoopback::ProcessEvent(), AnsaOSPF::InterfaceStateDown::ProcessEvent(), and AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent().

{
    MessageHandler* messageHandler = parentArea->GetRouter()->GetMessageHandler();
    messageHandler->ClearTimer(helloTimer);
    messageHandler->ClearTimer(waitTimer);
    messageHandler->ClearTimer(acknowledgementTimer);
    designatedRouter = NullDesignatedRouterID;
    backupDesignatedRouter = NullDesignatedRouterID;
    long neighborCount = neighboringRouters.size();
    for (long i = 0; i < neighborCount; i++) {
        neighboringRouters[i]->ProcessEvent(AnsaOSPF::Neighbor::KillNeighbor);
    }
}
void AnsaOSPF::Interface::SendDelayedAcknowledgements ( void  )

Definition at line 500 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), and AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent().

{
    AnsaOSPF::MessageHandler* messageHandler = parentArea->GetRouter()->GetMessageHandler();
    long                  maxPacketSize  = ((IPV4_HEADER_LENGTH + OSPF_HEADER_LENGTH + OSPF_LSA_HEADER_LENGTH) > mtu) ? IPV4_DATAGRAM_LENGTH : mtu;

    for (std::map<IPv4Address, std::list<OSPFLSAHeader>, AnsaOSPF::IPv4Address_Less>::iterator delayIt = delayedAcknowledgements.begin();
         delayIt != delayedAcknowledgements.end();
         delayIt++)
    {
        int ackCount = delayIt->second.size();
        if (ackCount > 0) {
            while (!(delayIt->second.empty())) {
                OSPFLinkStateAcknowledgementPacket* ackPacket  = new OSPFLinkStateAcknowledgementPacket;
                long                                packetSize = IPV4_HEADER_LENGTH + OSPF_HEADER_LENGTH;

                ackPacket->setType(LinkStateAcknowledgementPacket);
                ackPacket->setRouterID(parentArea->GetRouter()->GetRouterID());
                ackPacket->setAreaID(areaID);
                ackPacket->setAuthenticationType(authenticationType);
                for (int i = 0; i < 8; i++) {
                    ackPacket->setAuthentication(i, authenticationKey.bytes[i]);
                }

                while ((!(delayIt->second.empty())) && (packetSize <= (maxPacketSize - OSPF_LSA_HEADER_LENGTH))) {
                    unsigned long   headerCount = ackPacket->getLsaHeadersArraySize();
                    ackPacket->setLsaHeadersArraySize(headerCount + 1);
                    ackPacket->setLsaHeaders(headerCount, *(delayIt->second.begin()));
                    delayIt->second.pop_front();
                    packetSize += OSPF_LSA_HEADER_LENGTH;
                }

                ackPacket->setPacketLength(0); // TODO: Calculate correct length
                ackPacket->setChecksum(0); // TODO: Calculate correct cheksum(16-bit one's complement of the entire packet)

                int ttl = (interfaceType == AnsaOSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1;

                if (interfaceType == AnsaOSPF::Interface::Broadcast) {
                    if ((GetState() == AnsaOSPF::Interface::DesignatedRouterState) ||
                        (GetState() == AnsaOSPF::Interface::BackupState) ||
                        (designatedRouter == AnsaOSPF::NullDesignatedRouterID))
                    {
                        messageHandler->SendPacket(ackPacket, AnsaOSPF::AllSPFRouters, ifIndex, ttl);
                    } else {
                        messageHandler->SendPacket(ackPacket, AnsaOSPF::AllDRouters, ifIndex, ttl);
                    }
                } else {
                    if (interfaceType == AnsaOSPF::Interface::PointToPoint) {
                        messageHandler->SendPacket(ackPacket, AnsaOSPF::AllSPFRouters, ifIndex, ttl);
                    } else {
                        messageHandler->SendPacket(ackPacket, delayIt->first, ifIndex, ttl);
                    }
                }
            }
        }
    }
    messageHandler->StartTimer(acknowledgementTimer, acknowledgementDelay);
}
void AnsaOSPF::Interface::SendHelloPacket ( AnsaOSPF::IPv4Address  destination,
short  ttl = 1 
)

Definition at line 107 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::NeighborStateDown::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent(), and AnsaOSPF::HelloHandler::ProcessPacket().

{
    OSPFOptions options;
    OSPFHelloPacket* helloPacket = new OSPFHelloPacket;
    std::vector<AnsaOSPF::IPv4Address> neighbors;

    helloPacket->setRouterID(parentArea->GetRouter()->GetRouterID());
    helloPacket->setAreaID(parentArea->GetAreaID());
    helloPacket->setAuthenticationType(authenticationType);
    for (int i = 0; i < 8; i++) {
        helloPacket->setAuthentication(i, authenticationKey.bytes[i]);
    }

    if (((interfaceType == PointToPoint) &&
         (interfaceAddressRange.address == AnsaOSPF::NullIPv4Address)) ||
        (interfaceType == Virtual))
    {
        helloPacket->setNetworkMask(ULongFromIPv4Address(AnsaOSPF::NullIPv4Address));
    } else {
        helloPacket->setNetworkMask(ULongFromIPv4Address(interfaceAddressRange.mask));
    }
    memset(&options, 0, sizeof(OSPFOptions));
    options.E_ExternalRoutingCapability = parentArea->GetExternalRoutingCapability();
    helloPacket->setOptions(options);
    helloPacket->setHelloInterval(helloInterval);
    helloPacket->setRouterPriority(routerPriority);
    helloPacket->setRouterDeadInterval(routerDeadInterval);
    helloPacket->setDesignatedRouter(ULongFromIPv4Address(designatedRouter.ipInterfaceAddress));
    helloPacket->setBackupDesignatedRouter(ULongFromIPv4Address(backupDesignatedRouter.ipInterfaceAddress));
    long neighborCount = neighboringRouters.size();
    for (long j = 0; j < neighborCount; j++) {
        if (neighboringRouters[j]->GetState() >= AnsaOSPF::Neighbor::InitState) {
            neighbors.push_back(neighboringRouters[j]->GetAddress());
        }
    }
    unsigned int initedNeighborCount = neighbors.size();
    helloPacket->setNeighborArraySize(initedNeighborCount);
    for (unsigned int k = 0; k < initedNeighborCount; k++) {
        helloPacket->setNeighbor(k, ULongFromIPv4Address(neighbors[k]));
    }

    helloPacket->setPacketLength(0); // TODO: Calculate correct length
    helloPacket->setChecksum(0); // TODO: Calculate correct cheksum(16-bit one's complement of the entire packet)

    parentArea->GetRouter()->GetMessageHandler()->SendPacket(helloPacket, destination, ifIndex, ttl);
}
void AnsaOSPF::Interface::SendLSAcknowledgement ( OSPFLSAHeader *  lsaHeader,
IPv4Address  destination 
)

Definition at line 154 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPF::LinkStateUpdateHandler::ProcessPacket().

{
    OSPFOptions                         options;
    OSPFLinkStateAcknowledgementPacket* lsAckPacket = new OSPFLinkStateAcknowledgementPacket;

    lsAckPacket->setType(LinkStateAcknowledgementPacket);
    lsAckPacket->setRouterID(parentArea->GetRouter()->GetRouterID());
    lsAckPacket->setAreaID(parentArea->GetAreaID());
    lsAckPacket->setAuthenticationType(authenticationType);
    for (int i = 0; i < 8; i++) {
        lsAckPacket->setAuthentication(i, authenticationKey.bytes[i]);
    }

    lsAckPacket->setLsaHeadersArraySize(1);
    lsAckPacket->setLsaHeaders(0, *lsaHeader);

    lsAckPacket->setPacketLength(0); // TODO: Calculate correct length
    lsAckPacket->setChecksum(0); // TODO: Calculate correct cheksum(16-bit one's complement of the entire packet)

    int ttl = (interfaceType == AnsaOSPF::Interface::Virtual) ? VIRTUAL_LINK_TTL : 1;
    parentArea->GetRouter()->GetMessageHandler()->SendPacket(lsAckPacket, destination, ifIndex, ttl);
}
void AnsaOSPF::Interface::SetAcknowledgementDelay ( short  delay) [inline]

Definition at line 125 of file AnsaOSPFInterface.h.

{ acknowledgementDelay = delay; }
void AnsaOSPF::Interface::SetAddressRange ( IPv4AddressRange  range) [inline]

Definition at line 139 of file AnsaOSPFInterface.h.

{ interfaceAddressRange = range; }
void AnsaOSPF::Interface::SetArea ( Area *  area) [inline]

Definition at line 151 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::Area::AddInterface().

{ parentArea = area; }
void AnsaOSPF::Interface::SetAreaID ( AreaID  areaId) [inline]

Definition at line 115 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), and AnsaOSPFRouting::LoadInterfaceParameters().

{ areaID = areaId; }
void AnsaOSPF::Interface::SetAuthenticationKey ( AuthenticationKeyType  key) [inline]

Definition at line 137 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), AnsaOSPFRouting::LoadInterfaceParameters(), and AnsaOSPFRouting::LoadVirtualLink().

{ authenticationKey = key; }
void AnsaOSPF::Interface::SetAuthenticationType ( AuthenticationType  type) [inline]

Definition at line 135 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), AnsaOSPFRouting::LoadInterfaceParameters(), and AnsaOSPFRouting::LoadVirtualLink().

{ authenticationType = type; }
void AnsaOSPF::Interface::SetHelloInterval ( short  interval) [inline]

Definition at line 129 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), AnsaOSPFRouting::LoadInterfaceParameters(), and AnsaOSPFRouting::LoadVirtualLink().

{ helloInterval = interval; }
void AnsaOSPF::Interface::SetIfIndex ( unsigned char  index)

Definition at line 68 of file AnsaOSPFInterface.cc.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), and AnsaOSPFRouting::LoadInterfaceParameters().

{
    ifIndex = index;
    if (interfaceType == AnsaOSPF::Interface::UnknownType) {
        InterfaceEntry* routingInterface = InterfaceTableAccess().get()->getInterfaceById(ifIndex);
        interfaceAddressRange.address = IPv4AddressFromAddressString(routingInterface->ipv4Data()->getIPAddress().str().c_str());
        interfaceAddressRange.mask = IPv4AddressFromAddressString(routingInterface->ipv4Data()->getNetmask().str().c_str());
        mtu = routingInterface->getMTU();
    }
}
void AnsaOSPF::Interface::SetIsGoingDown ( bool  b) [inline]

Definition at line 156 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceStateBackup::ProcessEvent(), AnsaOSPF::InterfaceStateWaiting::ProcessEvent(), AnsaOSPF::InterfaceStatePointToPoint::ProcessEvent(), AnsaOSPF::InterfaceStateNotDesignatedRouter::ProcessEvent(), and AnsaOSPF::InterfaceStateDesignatedRouter::ProcessEvent().

{ isGoingDown = b; }
void AnsaOSPF::Interface::SetMTU ( unsigned short  ifMTU) [inline]

Definition at line 113 of file AnsaOSPFInterface.h.

{ mtu = ifMTU; }
void AnsaOSPF::Interface::SetOutputCost ( Metric  cost) [inline]

Definition at line 119 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), and AnsaOSPFRouting::LoadInterfaceParameters().

{ interfaceOutputCost = cost; }
void AnsaOSPF::Interface::SetPollInterval ( short  interval) [inline]

Definition at line 131 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), and AnsaOSPFRouting::LoadInterfaceParameters().

{ pollInterval = interval; }
void AnsaOSPF::Interface::SetRetransmissionInterval ( short  interval) [inline]

Definition at line 121 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), AnsaOSPFRouting::LoadInterfaceParameters(), and AnsaOSPFRouting::LoadVirtualLink().

{ retransmissionInterval = interval; }
void AnsaOSPF::Interface::SetRouterDeadInterval ( short  interval) [inline]

Definition at line 133 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), AnsaOSPFRouting::LoadInterfaceParameters(), and AnsaOSPFRouting::LoadVirtualLink().

{ routerDeadInterval = interval; }
void AnsaOSPF::Interface::SetRouterPriority ( unsigned char  priority) [inline]

Definition at line 127 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), and AnsaOSPFRouting::LoadInterfaceParameters().

{ routerPriority = priority; }
void AnsaOSPF::Interface::SetTransitAreaID ( AreaID  areaId) [inline]

Definition at line 117 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::LoadVirtualLink().

{ transitAreaID = areaId; }
void AnsaOSPF::Interface::SetTransmissionDelay ( short  delay) [inline]

Definition at line 123 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), AnsaOSPFRouting::LoadInterfaceParameters(), and AnsaOSPFRouting::LoadVirtualLink().

{ interfaceTransmissionDelay = delay; }
void AnsaOSPF::Interface::SetType ( OSPFInterfaceType  ifType) [inline]

Definition at line 109 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPFRouting::AnsaLoadInterface(), AnsaOSPFRouting::LoadInterfaceParameters(), and AnsaOSPFRouting::LoadVirtualLink().

{ interfaceType = ifType; }

Friends And Related Function Documentation

friend class InterfaceState [friend]

Definition at line 83 of file AnsaOSPFInterface.h.

Member Data Documentation

short AnsaOSPF::Interface::acknowledgementDelay [private]

Definition at line 75 of file AnsaOSPFInterface.h.

Referenced by GetAcknowledgementDelay(), and SetAcknowledgementDelay().

OSPFTimer* AnsaOSPF::Interface::acknowledgementTimer [private]

Definition at line 66 of file AnsaOSPFInterface.h.

Referenced by GetAcknowledgementTimer(), and Interface().

AreaID AnsaOSPF::Interface::areaID [private]

Definition at line 57 of file AnsaOSPFInterface.h.

Referenced by GetAreaID(), and SetAreaID().

AuthenticationKeyType AnsaOSPF::Interface::authenticationKey [private]

Definition at line 77 of file AnsaOSPFInterface.h.

Referenced by GetAuthenticationKey(), Interface(), and SetAuthenticationKey().

AuthenticationType AnsaOSPF::Interface::authenticationType [private]

Definition at line 76 of file AnsaOSPFInterface.h.

Referenced by GetAuthenticationType(), and SetAuthenticationType().

DesignatedRouterID AnsaOSPF::Interface::backupDesignatedRouter [private]

Definition at line 72 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceState::CalculateDesignatedRouter(), and GetBackupDesignatedRouter().

std::map<IPv4Address, std::list<OSPFLSAHeader>, IPv4Address_Less> AnsaOSPF::Interface::delayedAcknowledgements [private]

Definition at line 70 of file AnsaOSPFInterface.h.

DesignatedRouterID AnsaOSPF::Interface::designatedRouter [private]

Definition at line 71 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceState::CalculateDesignatedRouter(), and GetDesignatedRouter().

short AnsaOSPF::Interface::helloInterval [private]

Definition at line 59 of file AnsaOSPFInterface.h.

Referenced by GetHelloInterval(), and SetHelloInterval().

OSPFTimer* AnsaOSPF::Interface::helloTimer [private]

Definition at line 64 of file AnsaOSPFInterface.h.

Referenced by GetHelloTimer(), and Interface().

unsigned char AnsaOSPF::Interface::ifIndex [private]

Definition at line 54 of file AnsaOSPFInterface.h.

Referenced by GetIfIndex().

IPv4AddressRange AnsaOSPF::Interface::interfaceAddressRange [private]

Definition at line 56 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceState::CalculateDesignatedRouter(), GetAddressRange(), and SetAddressRange().

Metric AnsaOSPF::Interface::interfaceOutputCost [private]

Definition at line 73 of file AnsaOSPFInterface.h.

Referenced by GetOutputCost(), and SetOutputCost().

short AnsaOSPF::Interface::interfaceTransmissionDelay [private]

Definition at line 62 of file AnsaOSPFInterface.h.

Referenced by GetTransmissionDelay(), and SetTransmissionDelay().

OSPFInterfaceType AnsaOSPF::Interface::interfaceType [private]

Definition at line 51 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceState::CalculateDesignatedRouter(), GetType(), and SetType().

bool AnsaOSPF::Interface::isGoingDown [private]

Definition at line 81 of file AnsaOSPFInterface.h.

Referenced by IsGoingDown(), and SetIsGoingDown().

unsigned short AnsaOSPF::Interface::mtu [private]

Definition at line 55 of file AnsaOSPFInterface.h.

Referenced by GetMTU(), and SetMTU().

std::vector<Neighbor*> AnsaOSPF::Interface::neighboringRouters [private]

Definition at line 69 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceState::CalculateDesignatedRouter(), GetNeighbor(), and GetNeighborCount().

std::map<IPv4Address, Neighbor*, IPv4Address_Less> AnsaOSPF::Interface::neighboringRoutersByAddress [private]

Definition at line 68 of file AnsaOSPFInterface.h.

std::map<RouterID, Neighbor*> AnsaOSPF::Interface::neighboringRoutersByID [private]

Definition at line 67 of file AnsaOSPFInterface.h.

Area* AnsaOSPF::Interface::parentArea [private]

Definition at line 79 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceState::CalculateDesignatedRouter(), GetArea(), and SetArea().

short AnsaOSPF::Interface::pollInterval [private]

Definition at line 60 of file AnsaOSPFInterface.h.

Referenced by GetPollInterval(), and SetPollInterval().

InterfaceState* AnsaOSPF::Interface::previousState [private]

Definition at line 53 of file AnsaOSPFInterface.h.

Referenced by Interface().

short AnsaOSPF::Interface::retransmissionInterval [private]

Definition at line 74 of file AnsaOSPFInterface.h.

Referenced by GetRetransmissionInterval(), and SetRetransmissionInterval().

short AnsaOSPF::Interface::routerDeadInterval [private]

Definition at line 61 of file AnsaOSPFInterface.h.

Referenced by GetRouterDeadInterval(), and SetRouterDeadInterval().

unsigned char AnsaOSPF::Interface::routerPriority [private]

Definition at line 63 of file AnsaOSPFInterface.h.

Referenced by AnsaOSPF::InterfaceState::CalculateDesignatedRouter(), GetRouterPriority(), and SetRouterPriority().

InterfaceState* AnsaOSPF::Interface::state [private]

Definition at line 52 of file AnsaOSPFInterface.h.

Referenced by Interface().

AreaID AnsaOSPF::Interface::transitAreaID [private]

Definition at line 58 of file AnsaOSPFInterface.h.

Referenced by GetTransitAreaID(), and SetTransitAreaID().

OSPFTimer* AnsaOSPF::Interface::waitTimer [private]

Definition at line 65 of file AnsaOSPFInterface.h.

Referenced by GetWaitTimer(), and Interface().

The documentation for this class was generated from the following files: