RouteTable.c

/************************************************************************************
* Copyright (C) 2023                                                               *
* TETCOS, Bangalore. India                                                         *
*                                                                                  *
* Tetcos owns the intellectual property rights in the Product and its content.     *
* The copying, redistribution, reselling or publication of any or all of the       *
* Product or its content without express prior written consent of Tetcos is        *
* prohibited. Ownership and / or any other right relating to the software and all  *
* intellectual property rights therein shall remain at all times with Tetcos.      *
*                                                                                  *
* Author:    Shashi Kant Suman                                                     *
*                                                                                  *
* ---------------------------------------------------------------------------------*/
 
#include "main.h"
#include "AODV.h"
#include "List.h"
/**
This function adds the route in the Route table of the node. If the table is not there,
it creates one with a certain timeout after which the entries are deleted.
*/
 
static FILE* AODV_log_fp = NULL;
 
int fn_NetSim_AODV_InsertInRouteTable(NETSIM_IPAddress ip,
    unsigned int seqNumber,
    unsigned int hopCount,
    NETSIM_IPAddress nextHop,
    double lifeTime,
    NetSim_EVENTDETAILS* pstruEventDetails)
{
    AODV_DEVICE_VAR* devVar = AODV_DEV_VAR(pstruEventDetails->nDeviceId);
    AODV_ROUTETABLE* table = devVar->routeTable;
    double AODV_log_lifetime = 0;
    bool flag = false;
    while(table)
    {
        if(!IP_COMPARE(table->DestinationIPAddress,ip) /*&& 
           table->routingFlags == AODV_RoutingFlag_Valid*/)
        {
            if(table->ValidDestinationSequenceNumberflag == false)
                break;
            if(table->DestinationSequenceNumber < seqNumber)
                break;
            if(table->DestinationSequenceNumber > seqNumber)
                return 1;
            if(hopCount+1<table->HopCount || table->routingFlags==AODV_RoutingFlag_InValid)
                break;
            else
                return 1;
        }
        table = LIST_NEXT(table);
    }
    if(!table)
    {
        NetSim_EVENTDETAILS pevent;
        //Create new table
        table = ROUTETABLE_ALLOC();
        table->Lifetime = pstruEventDetails->dEventTime+AODV_ACTIVE_ROUTE_TIMEOUT;
        LIST_ADD_LAST(&AODV_DEV_VAR(pstruEventDetails->nDeviceId)->routeTable,table);
        //Add an event for active route time out
        pevent.dEventTime = pstruEventDetails->dEventTime+AODV_ACTIVE_ROUTE_TIMEOUT;
        pevent.dPacketSize = 0;
        pevent.nApplicationId = 0;
        pevent.nDeviceId = pstruEventDetails->nDeviceId;
        pevent.nDeviceType = pstruEventDetails->nDeviceType;
        pevent.nEventType = TIMER_EVENT;
        pevent.nInterfaceId = pstruEventDetails->nInterfaceId;
        pevent.nPacketId = 0;
        pevent.nPrevEventId = pstruEventDetails->nPrevEventId;
        pevent.nProtocolId = NW_PROTOCOL_AODV;
        pevent.nSegmentId = 0;
        pevent.nSubEventType = AODVsubevent_ACTIVE_ROUTE_TIMEOUT;
        pevent.pPacket = NULL;
        pevent.szOtherDetails = IP_COPY(ip);
        fnpAddEvent(&pevent);
        flag = true;
    }
    if(!table->DestinationIPAddress)
        table->DestinationIPAddress = IP_COPY(ip);
    table->DestinationSequenceNumber = seqNumber;
    table->HopCount= hopCount;
    AODV_log_lifetime = table->Lifetime;
    table->Lifetime = max(table->Lifetime,lifeTime);
    table->ListofPrecursors = devVar->precursorsList;
    table->NetworkInterface = 1;
    if (table->NextHop)
        IP_FREE(table->NextHop);
    table->NextHop = IP_COPY(nextHop);
    table->routingFlags = AODV_RoutingFlag_Valid;
    if(table->DestinationSequenceNumber)
        table->ValidDestinationSequenceNumberflag = true;
    //AODV DEVICE LOG
    if (flag)
        fn_NetSim_AODV_Route_Table_Log_Update(pstruEventDetails->nDeviceId, "New Entry");
    else
        if (AODV_log_lifetime < lifeTime)
            fn_NetSim_AODV_Route_Table_Log_Update(pstruEventDetails->nDeviceId, "Lifetime extended");
    return 1;
}
/**
This function adds the given IP in the ADOV precursor list if not already present.
*/
int fn_NetSim_AODV_InsertInPrecursorsList(NETSIM_IPAddress ip,NetSim_EVENTDETAILS* pstruEventDetails)
{
    int loop;
    AODV_PRECURSORS_LIST* precursorsList = AODV_DEV_VAR(pstruEventDetails->nDeviceId)->precursorsList;
    if(!precursorsList)
    {
        precursorsList = calloc(1,sizeof* precursorsList);
        AODV_DEV_VAR(pstruEventDetails->nDeviceId)->precursorsList = precursorsList;
    }
    for(loop=0;loop<precursorsList->count;loop++)
    {
        if(!IP_COMPARE(precursorsList->list[loop],ip))
            return 0; //ip already present in list
    }
    if(!precursorsList->count)
        precursorsList->list = calloc(1,sizeof* precursorsList->list);
    else
        precursorsList->list = realloc(precursorsList->list,(precursorsList->count+1)*(sizeof* precursorsList->list));
    precursorsList->list[precursorsList->count] = IP_COPY(ip);
    precursorsList->count++;
    return 1;
}
/**
This function returns the next hop IP to the destination from the Route Table
*/
NETSIM_IPAddress fn_NetSim_AODV_FindNextHop(AODV_DEVICE_VAR* devVar,
    NETSIM_IPAddress dest,
    NetSim_EVENTDETAILS* pstruEventDetails)
{
    AODV_ROUTETABLE* table=devVar->routeTable;
    while(table)
    {
        if(!IP_COMPARE(table->DestinationIPAddress,dest) &&
           table->routingFlags == AODV_RoutingFlag_Valid)
            return table->NextHop;
        table = LIST_NEXT(table);
    }
    return NULL;
}
/**
This function returns the Route table with the mentioned destination IP
*/
AODV_ROUTETABLE* fnFindRouteTable(AODV_ROUTETABLE* table,NETSIM_IPAddress dest)
{
    while(table)
    {
        if(!IP_COMPARE(table->DestinationIPAddress,dest))
        {
            return table;
        }
        table = LIST_NEXT(table);
    }
    return NULL;
}
/**
This function updates the lifetime of the Route Table
*/
int fn_NetSim_AODV_UpdateRouteTable(NETSIM_IPAddress ip,
    double lifetime,
    NetSim_EVENTDETAILS* pstruEventDetails)
{
    //AODV DEVICE LOG
    double AODV_log_lifetime = 0;
 
    AODV_ROUTETABLE* table = AODV_DEV_VAR(pstruEventDetails->nDeviceId)->routeTable;
    while(table)
    {
        if(!IP_COMPARE(table->NextHop,ip) || !IP_COMPARE(table->DestinationIPAddress,ip))
        {
            //AODV DEVICE LOG
            AODV_log_lifetime = table->Lifetime;
 
            table->Lifetime = max(table->Lifetime,lifetime);
        }
        table=LIST_NEXT(table);
    }
    //AODV DEVICE LOG
    if (AODV_log_lifetime < lifetime)
        fn_NetSim_AODV_Route_Table_Log_Update(pstruEventDetails->nDeviceId, "Lifetime Extended");
    return 1;
}
/**
This function adds the timeout event of a Route Table which is equal to the table_LifeTime
*/
int fn_NetSim_AODV_ActiveRouteTimeout(NetSim_EVENTDETAILS* pstruEventDetails)
{
    int flag = 0;
    NETSIM_IPAddress dest = (NETSIM_IPAddress)pstruEventDetails->szOtherDetails;
    AODV_ROUTETABLE* table = AODV_DEV_VAR(pstruEventDetails->nDeviceId)->routeTable;
    while(table)
    {
        if(!IP_COMPARE(table->DestinationIPAddress,dest))
        {
            if(table->Lifetime <= pstruEventDetails->dEventTime)
            {
                AODV_ROUTETABLE* temp = LIST_NEXT(table);
                IP_FREE(table->DestinationIPAddress);
                IP_FREE(table->NextHop);
                LIST_FREE(&AODV_DEV_VAR(pstruEventDetails->nDeviceId)->routeTable,table);
                table = temp;
                continue;
            }
            else
            {
                //Add new time out event
                pstruEventDetails->dEventTime = table->Lifetime;
                pstruEventDetails->szOtherDetails = dest;
                fnpAddEvent(pstruEventDetails);
                flag = 1;
            }
        }
        table=(AODV_ROUTETABLE*)LIST_NEXT(table);
    }
    //AODV DEVICE LOG
    if(!flag)
    {
        sprintf(comment, "AODV active route timed out");
        fn_NetSim_AODV_Route_Table_Log_Update(pstruEventDetails->nDeviceId, "Entry Deleted");
        IP_FREE(dest);
    }
    return 1;
}
 
int fn_NetSim_AODV_Route_Table_Log_Init()
{
    if (!AODV_LOG_ENABLED())
        return 0; // Skip logging if not enabled
 
    char AODV_Log_filename[BUFSIZ];
 
    sprintf(AODV_Log_filename, "%s\\AODV_Route_Table_log.csv", pszIOLogPath);
 
    AODV_log_fp = fopen(AODV_Log_filename, "w");
    if (!AODV_log_fp)
    {
        fnSystemError("Unable to open %s file", AODV_Log_filename);
        perror(AODV_Log_filename);
    }
    else
    {
        fprintf(AODV_log_fp,"%s,%s,%s,%s,%s,%s,%s,%s,%s,%s", "Time(MicroSeconds)", "Device Name", "DestinationIPAddress", 
            "DestinationSequenceNumber", "NetworkInterface", "HopCount", "NextHop", 
            "Lifetime(Microseconds)", "Event", "Comments");
 
        fprintf(AODV_log_fp, "\n");
        if (nDbgFlag) fflush(AODV_log_fp);
    }
}
 
int fn_NetSim_AODV_Route_Table_Log_Update(NETSIM_ID devid, char* msg)
 
{
    if (!AODV_LOG_ENABLED())
        return 0; // Skip logging if not enabled
 
    if(AODV_log_fp)
    {
        AODV_ROUTETABLE* table = AODV_DEV_VAR(devid)->routeTable;
        while (table)
        {
            (table->DestinationIPAddress)->str_ip;
            fprintf(AODV_log_fp, "%lf,%s,%s, %d,%d,%d,%s,%f,%s,%s", pstruEventDetails->dEventTime,
                DEVICE_NAME(devid), (table->DestinationIPAddress)->str_ip,
                table->DestinationSequenceNumber, table->NetworkInterface, table->HopCount,
                (table->NextHop)->str_ip, table->Lifetime, msg, comment);
            
            fprintf(AODV_log_fp, "\n");
            if (nDbgFlag) fflush(AODV_log_fp);
 
            table = (AODV_ROUTETABLE*)LIST_NEXT(table);
        }   
    }
    return 0;
 
}
 
void fn_NetSim_AODV_Route_Table_Log_Finish()
{
    if (AODV_log_fp)
        fclose(AODV_log_fp);
}