Ethernet.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.       *
*                                                                                   *
* This source code is licensed per the NetSim license agreement.                    *
*                                                                                   *
* No portion of this source code may be used as the basis for a derivative work,    *
* or used, for any purpose other than its intended use per the NetSim license       *
* agreement.                                                                        *
*                                                                                   *
* This source code and the algorithms contained within it are confidential trade    *
* secrets of TETCOS and may not be used as the basis for any other software,        *
* hardware, product or service.                                                     *
*                                                                                   *
* Author:    Shashi Kant Suman                                                      *
*                                                                                   *
* ----------------------------------------------------------------------------------*/
#include "main.h"
#include "Ethernet.h"
#include "Ethernet_enum.h"
#include "AdvancedPlots.h"
#pragma comment(lib,"AdvancedPlots.lib")
char* GetStringEthernet_Subevent(NETSIM_ID);
 
#pragma comment(lib,"Ethernet.lib")
 
//Function prototype
int fn_NetSim_Ethernet_Configure_F(void **var);
int fn_NetSim_Ethernet_Init_F(struct stru_NetSim_Network* net,
                         NetSim_EVENTDETAILS* pevent,
                         char* appPath,
                         char* iopath,
                         int version,
                         void** fnPointer);
int fn_NetSim_Ethernet_CopyPacket_F(NetSim_PACKET* dst,
                               NetSim_PACKET* src);
int fn_NetSim_Ethernet_FreePacket_F(NetSim_PACKET* packet);
int fn_NetSim_Ethernet_Finish_F();
int fn_NetSim_Ethernet_Metrics_F(PMETRICSWRITER metricsWriter);
char* fn_NetSim_Ethernet_ConfigPacketTrace_F(const void* xmlNetSimNode);
int fn_NetSim_Ethernet_WritePacketTrace_F(NetSim_PACKET* pstruPacket, char** ppszTrace);
 
int fn_NetSim_Ethernet_HandleMacOut();
int fn_NetSim_Ethernet_HandleMacIn();
int fn_NetSim_Ethernet_HandlePhyOut();
int fn_NetSim_Ethernet_HandlePhyIn();
static int fn_NetSim_Ethernet_HandleTimer();
 
/**
This function is called by NetworkStack.dll, whenever the event gets triggered
inside the NetworkStack.dll for the Mac/Phy layer Ethernet protocol
It includes MAC_OUT, MAC_IN, PHY_OUT, PHY_IN and TIMER_EVENT.
*/
_declspec (dllexport) int fn_NetSim_Ethernet_Run()
{
    switch (pstruEventDetails->nEventType)
    {
    case MAC_OUT_EVENT:
        return fn_NetSim_Ethernet_HandleMacOut();
        break;
    case MAC_IN_EVENT:
        return fn_NetSim_Ethernet_HandleMacIn();
        break;
    case PHYSICAL_OUT_EVENT:
        return fn_NetSim_Ethernet_HandlePhyOut();
        break;
    case PHYSICAL_IN_EVENT:
        return fn_NetSim_Ethernet_HandlePhyIn();
        break;
    case TIMER_EVENT:
        return fn_NetSim_Ethernet_HandleTimer();
        break;
    default:
        fnNetSimError("Unknown event %d for Ethernet protocolin %s\n",
                      pstruEventDetails->nEventType,
                      __FUNCTION__);
        return -1;
    }
}
 
/**
This function is called by NetworkStack.dll, while configuring the device
Mac/Phy layer for Ethernet protocol.
*/
_declspec(dllexport) int fn_NetSim_Ethernet_Configure(void** var)
{
    return fn_NetSim_Ethernet_Configure_F(var);
}
 
/**
This function initializes the Ethernet parameters.
*/
_declspec (dllexport) int fn_NetSim_Ethernet_Init(struct stru_NetSim_Network *NETWORK_Formal,
                                             NetSim_EVENTDETAILS *pstruEventDetails_Formal,
                                             char *pszAppPath_Formal,
                                             char *pszWritePath_Formal,
                                             int nVersion_Type,
                                             void **fnPointer)
{
    init_linkpacketlog();
    return fn_NetSim_Ethernet_Init_F(NETWORK_Formal,
                                pstruEventDetails_Formal,
                                pszAppPath_Formal,
                                pszWritePath_Formal,
                                nVersion_Type,
                                fnPointer);
}
 
/**
This function is called by NetworkStack.dll, once simulation end to free the
allocated memory for the network.
*/
_declspec(dllexport) int fn_NetSim_Ethernet_Finish()
{
    return fn_NetSim_Ethernet_Finish_F();
}
 
/**
This function is called by NetworkStack.dll, while writing the event trace
to get the sub event as a string.
*/
_declspec (dllexport) char *fn_NetSim_Ethernet_Trace(int nSubEvent)
{
    return (GetStringEthernet_Subevent(nSubEvent));
}
 
/**
This function is called by NetworkStack.dll, to free the Ethernet protocol
*/
_declspec(dllexport) int fn_NetSim_Ethernet_FreePacket(NetSim_PACKET* pstruPacket)
{
    return fn_NetSim_Ethernet_FreePacket_F(pstruPacket);
}
 
/**
This function is called by NetworkStack.dll, to copy the Ethernet protocol from source packet to destination.
*/
_declspec(dllexport) int fn_NetSim_Ethernet_CopyPacket(NetSim_PACKET* pstruDestPacket, NetSim_PACKET* pstruSrcPacket)
{
    return fn_NetSim_Ethernet_CopyPacket_F(pstruDestPacket, pstruSrcPacket);
}
 
/**
This function write the Metrics in Metrics.txt
*/
_declspec(dllexport) int fn_NetSim_Ethernet_Metrics(PMETRICSWRITER metricsWriter)
{
    return fn_NetSim_Ethernet_Metrics_F(metricsWriter);
}
 
/**
This function will return the string to write packet trace heading.
*/
_declspec(dllexport) char* fn_NetSim_Ethernet_ConfigPacketTrace(const void* xmlNetSimNode)
{
    return fn_NetSim_Ethernet_ConfigPacketTrace_F(xmlNetSimNode);
}
 
/**
This function will return the string to write packet trace.
*/
_declspec(dllexport) int fn_NetSim_Ethernet_WritePacketTrace(NetSim_PACKET* pstruPacket, char** ppszTrace)
{
    return fn_NetSim_Ethernet_WritePacketTrace_F(pstruPacket, ppszTrace);
}
 
static int fn_NetSim_Ethernet_HandleTimer()
{
    switch (pstruEventDetails->nSubEventType)
    {
        case ETH_IF_UP:
            notify_interface_up(pstruEventDetails->nDeviceId, pstruEventDetails->nInterfaceId);
            break;
    default:
        fnNetSimError("Unknown subevent %d in %s\n",
                      pstruEventDetails->nSubEventType,
                      __FUNCTION__);
        break;
    }
    return 0;
}
/* Ethernet IPG[1]
Ethernet variant                Minimum transmitted IPG         Minimum received IPG
 
10 Mbit/s Ethernet              9.6 µs                          4.7 µs (47 bit times)
100 Mbit/s (Fast) Ethernet      0.96 µs                         0.96 µs (96 bit times)
Gigabit Ethernet                96 ns                           64 ns (64 bit times)
2.5 Gigabit Ethernet            38.4 ns                         16 ns (40 bit times)
5 Gigabit Ethernet              19.2 ns                         8 ns (40 bit times)
10 Gigabit Ethernet             9.6 ns                          4 ns (40 bit times)
25 Gigabit Ethernet             3.84 ns                         1.6 ns (40 bit times)
40 Gigabit Ethernet             2.4 ns                          200 ps (8 bit times)
50 Gigabit Ethernet             1.92 ns                         160 ps (8 bit times)
100 Gigabit Ethernet            0.96 ns                         80 ps (8 bit times)
200 Gigabit Ethernet            0.48 ns                         40 ps (8 bit times)
400 Gigabit Ethernet            0.24 ns                         20 ps (8 bit times)
*/
double get_ifg(double link_speed)
{
    NETSIM_ID ifg_bits;
 
    if (link_speed <= 10)         // 10 Mbit/s Ethernet
        ifg_bits = 47;
    else if (link_speed <= 100)   // 100 Mbit/s Ethernet
        ifg_bits = 96;
    else if (link_speed <= 1000)     // 1Gbit Ethernet
        ifg_bits = 64;
    else if (link_speed <= 25000)    // 2.5/5/10/25 Gbit Ethernet
        ifg_bits = 40;
    else                                // 40G/50G/100G/200G/400G
        ifg_bits = 8;
 
    /*Convert IFG to microseconds
    IFG (in microseconds) = Ifg_bits / (Link_speed) */
    return ((double)ifg_bits) / link_speed;
}