LinkTM-Capture-Software-12.15/Reference-Documentation/replay4ga_largefile_example.c-Source-File

/*
 *
 * Copyright 2025 Napatech A/S. All Rights Reserved.
 *
 * 1. Copying, modification, and distribution of this file, or executable
 * versions of this file, is governed by the terms of the Napatech Software
 * license agreement under which this file was made available. If you do not
 * agree to the terms of the license do not install, copy, access or
 * otherwise use this file.
 *
 * 2. Under the Napatech Software license agreement you are granted a
 * limited, non-exclusive, non-assignable, copyright license to copy, modify
 * and distribute this file in conjunction with Napatech SmartNIC's and
 * similar hardware manufactured or supplied by Napatech A/S.
 *
 * 3. The full Napatech Software License Agreement is included in this
 * distribution, please see "NA-0009 Software License Agreement.pdf"
 *
 * 4. Redistributions of source code must retain this copyright notice,
 * list of conditions and the following disclaimer.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTIES, EXPRESS OR
 * IMPLIED, AND NAPATECH DISCLAIMS ALL IMPLIED WARRANTIES INCLUDING ANY
 * IMPLIED WARRANTY OF TITLE, MERCHANTABILITY, NONINFRINGEMENT, OR OF
 * FITNESS FOR A PARTICULAR PURPOSE. TO THE EXTENT NOT PROHIBITED BY
 * APPLICABLE LAW, IN NO EVENT SHALL NAPATECH BE LIABLE FOR PERSONAL INJURY,
 * OR ANY INCIDENTAL, SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES WHATSOEVER,
 * INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF PROFITS, CORRUPTION OR
 * LOSS OF DATA, FAILURE TO TRANSMIT OR RECEIVE ANY DATA OR INFORMATION,
 * BUSINESS INTERRUPTION OR ANY OTHER COMMERCIAL DAMAGES OR LOSSES, ARISING
 * OUT OF OR RELATED TO YOUR USE OR INABILITY TO USE NAPATECH SOFTWARE OR
 * SERVICES OR ANY THIRD PARTY SOFTWARE OR APPLICATIONS IN CONJUNCTION WITH
 * THE NAPATECH SOFTWARE OR SERVICES, HOWEVER CAUSED, REGARDLESS OF THE THEORY
 * OF LIABILITY (CONTRACT, TORT OR OTHERWISE) AND EVEN IF NAPATECH HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. SOME JURISDICTIONS DO NOT ALLOW
 * THE EXCLUSION OR LIMITATION OF LIABILITY FOR PERSONAL INJURY, OR OF
 * INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS LIMITATION MAY NOT APPLY TO YOU.
 *
 *

 */

// Include this in order to access the Napatech API
#include <nt.h>

#if defined(__linux__) || defined(__FreeBSD__)
  #include <unistd.h> // sleep()
  #include <stdatomic.h>
#endif

#include <stdlib.h>
#include <signal.h>
#include <argparse.h>

#define ONEMBIT (1000000ULL)

/**
  * Print command line info
  */
static const char *usageText[] = {
  "Syntax:\n"
    "replay4ga_largefile_example [-h][-p <port no.>][-f <file name>]\n"
    "Example: replay4ga_largefile_example -p 1 -f mycapture.cap\n",
  NULL
};

static int opt_port = 0;
static char *opt_filename;

#if defined(WIN32) || defined (WIN64)
static volatile int appRunning = 1; // The application will run as long as appRunning == 1
#else
static atomic_int appRunning = 1;   // The application will run as long as appRunning == 1
#endif


/**
 * Table of valid options.
 */
struct argparse_option arg_options[] = {
  OPT_HELP(),
  OPT_INTEGER('p', "port", &opt_port, "Tx port", NULL, 0, 0, "port number"),
  OPT_STRING('f', "filename", &opt_filename, "File name\n", NULL, 0, 0, "value"),
  OPT_END(),
};


/**
  * The function called when user is pressing CTRL-C
  */
#if defined(WIN32) || defined (WIN64)
static BOOL WINAPI StopApplication(int sig)
{
  (void) sig;
  appRunning = 0;
  return TRUE;
}
#else
static void StopApplication(int sig)
{
  if (sig == SIGINT)
    appRunning = 0;
}
#endif


int
main(int argc, const char **argv)
{
  char errorBuffer[NT_ERRBUF_SIZE]; // Error buffer
  int status;     // Status variable
  NtNetStreamFile_t hNetFile; // Handle to the File stream
  NtNetBuf_t hNetBufFile; // Net buffer container. Used to return segments from the file stream
  NtNetStreamTx_t hNetTx; // Handle to the TX stream
  NtNetBuf_t hNetBufTx;   // Net buffer container. Used when getting a transmit buffer
  NtInfoStream_t hInfo;   // Handle to a info stream
  NtInfo_t infoRead;    // Buffer to hold data from infostream
  NtConfigStream_t hConfig; // Handle to a config stream
  NtConfig_t configRead;  // Config stream data container
  NtConfig_t configWrite; // Config stream data container
  uint8_t adapterNo;    // Adapter no
  uint64_t firstPacketTS = 0; // Timestamp of first packet
  uint64_t lastPacketTS = 0;  // Timestamp of last packet
  uint64_t adapterTS = 0; // Timestamp on the adapter
  uint64_t timeDelta = 0; // Calculated time delta
  uint64_t timeDeltaAdjust = 0; // Calculated time delta adjust
  uint64_t speed;   // Tx port speed
  uint64_t tx_time_for_last_pkt;  // Calculated transmission time for last packet
  uint64_t segment_length = 0;
  uint64_t last_segment_length = 0;

  struct argparse argparse;
  uint64_t last_pkt_size = 0;

  // Register ctrl+c handler so we are able to stop again
#if defined(WIN32) || defined (WIN64)
  SetConsoleCtrlHandler((PHANDLER_ROUTINE) StopApplication, TRUE);
#else
  struct sigaction newaction; // Ctrl+c signal handler container
  memset(&newaction, 0, sizeof(newaction));
  newaction.sa_handler = StopApplication;
  if (sigaction(SIGINT, &newaction, NULL) < 0) {
    fprintf(stderr, "Failed to register SIGINT sigaction.\n");
    exit(EXIT_FAILURE);
  }
#endif

  argparse_init(&argparse, arg_options, usageText, 0);
  argparse_parse(&argparse, argc, argv);

  // Initialize the NTAPI library and thereby check if NTAPI_VERSION can be used together with this library
  if ((status = NT_Init(NTAPI_VERSION)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_Init() failed: %s\n", errorBuffer);
    return -1;
  }

  // Open the infostream.
  if ((status = NT_InfoOpen(&hInfo, "replay")) != NT_SUCCESS) {
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_InfoOpen() failed: %s\n", errorBuffer);
    return -1;
  }

  // Check whether or not TX is supported on the defined port
  infoRead.cmd = NT_INFO_CMD_READ_PORT_V10;
  infoRead.u.port_v10.portNo = (uint8_t)opt_port;  // TX port
  if ((status = NT_InfoRead(hInfo, &infoRead)) != NT_SUCCESS) {
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_InfoRead() failed: %s\n", errorBuffer);
    NT_InfoClose(hInfo);
    return -1;
  }

  // read port speed to use for calculating transmission time for last packet
  switch (infoRead.u.port_v10.data.speed)
  {

  case NT_LINK_SPEED_10M:
    speed = 10ULL * ONEMBIT;
    break;
  case NT_LINK_SPEED_100M:
    speed = 100ULL * ONEMBIT;
    break;
  case NT_LINK_SPEED_1G:
    speed = 1000ULL * ONEMBIT;
    break;
  case NT_LINK_SPEED_10G:
    speed = 10000ULL * ONEMBIT;
    break;
  case NT_LINK_SPEED_25G:
    speed = 25000ULL * ONEMBIT;
    break;
  case NT_LINK_SPEED_40G:
    speed = 40000ULL * ONEMBIT;
    break;
  case NT_LINK_SPEED_100G:
    speed = 100000ULL * ONEMBIT;
    break;
  case NT_LINK_SPEED_200G:
    speed = 200000ULL * ONEMBIT;
    break;
  default:
    fprintf(stderr, "BUG: Unhandled port speed\n");
    NT_InfoClose(hInfo);
    return -1;
  }

  if (infoRead.u.port_v10.data.state == NT_LINK_STATE_DOWN) {
    fprintf(stderr, "Port %d has no link\n", opt_port);
    NT_InfoClose(hInfo);
    return -1;
  }

  if (infoRead.u.port_v10.data.capabilities.featureMask & NT_PORT_FEATURE_RX_ONLY) {
    fprintf(stderr, "Transmit is not possible on the selected port %d\n", opt_port);
    NT_InfoClose(hInfo);
    return -1;
  }

  // save adapter number of the TX port
  adapterNo = infoRead.u.port_v10.data.adapterNo;
  NT_InfoClose(hInfo);

  uint64_t totalSize = 0;
  uint64_t totalSegments = 0;

  // Open the capture file to replay - for this purpose, just open it in PACKET mode and read packet by packet.
  if ((status = NT_NetFileOpen(&hNetFile, "FileStream", NT_NET_INTERFACE_SEGMENT, opt_filename)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_NetFileOpen() failed: %s\n", errorBuffer);
    return -1;
  }

  // Issue get so we can read first packet timstamp
  if ((status = NT_NetFileGet(hNetFile, &hNetBufFile)) != NT_SUCCESS) {
    if (status == NT_STATUS_END_OF_FILE) {
      fprintf(stderr, "The file %s has no data\n", opt_filename);
      return -1;
    }
  }

  firstPacketTS = NT_NET_GET_PKT_TIMESTAMP(hNetBufFile) * 10;
  totalSize += NT_NET_GET_SEGMENT_LENGTH(hNetBufFile);
  totalSegments ++;

  do {
    status = NT_NetFileGet(hNetFile, &hNetBufFile);
    if (status != NT_STATUS_END_OF_FILE) {
      lastPacketTS = NT_NET_GET_PKT_TIMESTAMP(hNetBufFile) * 10;
      last_pkt_size = (uint64_t)NT_NET_GET_PKT_WIRE_LENGTH(hNetBufFile) + 20;
      totalSize += NT_NET_GET_SEGMENT_LENGTH(hNetBufFile);
      totalSegments ++;
    }
  }
  while (status != NT_STATUS_END_OF_FILE);

  // Close the file again. We will open it again later to actually transmit packets.
  NT_NetFileClose(hNetFile);

  // Open the config stream
  if ((status = NT_ConfigOpen(&hConfig, "replay")) != NT_SUCCESS) {
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_ConfigOpen() failed: %s\n", errorBuffer);
    NT_ConfigClose(hConfig);
    return -1;
  }

  // Open the capture file to replay
  if ((status =  NT_NetFileOpen(&hNetFile, "FileStream", NT_NET_INTERFACE_SEGMENT, opt_filename)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_NetFileOpen() failed: %s\n", errorBuffer);
    return -1;
  }

  uint64_t requiredHostbuffer = totalSize / (1024UL * 1024UL);
  printf("Required host buffer: %lu MiB (Actual size: %lu MiB)\n", totalSegments, requiredHostbuffer);
  // Open a TX hostbuffer from TX host buffer pool on the NUMA node of the adapter with the defined port
  //if ((status = NT_NetTxOpen_v3(&hNetTx, "TxStreamPort", (0x1 << opt_port), NT_NETTX_NUMA_ADAPTER_HB, totalSize, NT_PACKET_DESCRIPTOR_TYPE_NT, NT_TIMESTAMP_TYPE_NATIVE_UNIX)) != NT_SUCCESS) {
  if ((status = NT_NetTxOpen(&hNetTx, "TxStreamPort", 1ULL << opt_port, NT_NETTX_NUMA_ADAPTER_HB, (uint32_t)totalSegments)) != NT_SUCCESS) {
    // Get the status code as text
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_NetTxOpen() failed: %s\n", errorBuffer);
    return -1;
  }

  //Read the adapter time
  configRead.parm = NT_CONFIG_PARM_ADAPTER_TIMESTAMP;
  configRead.u.timestampRead.adapter = adapterNo;
  if ((status = NT_ConfigRead(hConfig, &configRead)) != NT_SUCCESS) {
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_ConfigRead() failed: %s\n", errorBuffer);
    NT_ConfigClose(hConfig);
    return -1;
  }
  adapterTS = configRead.u.timestampRead.data.nativeUnixTs * 10;  // Convert 10ns ticks to 1ns

  // last frame time stamp - first frame time stamp + estimated transmission time for last frame
  tx_time_for_last_pkt = (last_pkt_size * 8U * 100000000ULL) / speed;
  timeDeltaAdjust = lastPacketTS - firstPacketTS + tx_time_for_last_pkt;

  // Start transfer 10 seconds from now
  timeDelta = (adapterTS - firstPacketTS) + 10000000000UL;
  printf("Transfer starts in 10 seconds from now\n");

  // Configure transmit on timestamp
  configWrite.parm = NT_CONFIG_PARM_PORT_TRANSMIT_ON_TIMESTAMP;
  configWrite.u.transmitOnTimestamp.portNo = (uint8_t) opt_port;
  configWrite.u.transmitOnTimestamp.data.timeDelta = timeDelta;
  configWrite.u.transmitOnTimestamp.data.timeDeltaAdjust = timeDeltaAdjust;
  configWrite.u.transmitOnTimestamp.data.enable = true;
  configWrite.u.transmitOnTimestamp.data.forceTxOnTs = false;
  if ((status = NT_ConfigWrite(hConfig, &configWrite)) != NT_SUCCESS) {
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_ConfigWrite() failed: %s\n", errorBuffer);
    NT_ConfigClose(hConfig);
    return 0;
  }

  printf("Capture file duration: %.01fs\n", (double)timeDeltaAdjust / 1000000000);
  printf("NOTICE: First repetition may be slower than capture rate!\n");

  NtNetBuf_t *netBufs = malloc(totalSegments * sizeof(NtNetBuf_t));
  if (netBufs == NULL) {
    fprintf(stderr, "Could not allocate tx segment pointer array\n");
    return -1;
  }

  for (uint32_t i = 0; i < totalSegments; i++) {
    if ((status = NT_NetFileGet(hNetFile, &hNetBufFile)) != NT_SUCCESS) {
      // Get the status code as text
      NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
      fprintf(stderr, "NT_NetFileGet() failed: %s\n", errorBuffer);
      goto ExitError;
    }

    if ((status = NT_NetTxGet(hNetTx, &netBufs[i], (uint32_t)opt_port, NT_NET_GET_SEGMENT_LENGTH(hNetBufFile), NT_NETTX_SEGMENT_OPTION_RAW, -1))) {
      // Get the status code as text
      NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
      fprintf(stderr, "NT_NetTxGet() failed: %s\n", errorBuffer);
      goto ExitError;
    }

    if (i == totalSegments - 1)
      last_segment_length = NT_NET_GET_SEGMENT_LENGTH(hNetBufFile);
    else
      segment_length = NT_NET_GET_SEGMENT_LENGTH(hNetBufFile);

    memcpy(NT_NET_GET_SEGMENT_PTR(netBufs[i]), NT_NET_GET_SEGMENT_PTR(hNetBufFile), NT_NET_GET_SEGMENT_LENGTH(hNetBufFile));

    if ((status = NT_NetFileRelease(hNetFile, hNetBufFile)) != NT_SUCCESS) {
      // Get the status code as text
      NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
      fprintf(stderr, "NT_NetFileRelease() failed: %s\n", errorBuffer);
      goto ExitError;
    }

    // Due to a potential bug, tx segments are released right after filling,
    // resulting in potentially slower initial transmit
    if ((status = NT_NetTxRelease(hNetTx, netBufs[i])) != NT_SUCCESS) {
      // Get the status code as text
      NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
      fprintf(stderr, "NT_NetTxRelease() failed: %s\n", errorBuffer);
      goto ExitError;
    }
  }

  // Close the file stream
  NT_NetFileClose(hNetFile);

  // // Release the loaded tx segments
  // for (uint32_t i = 0; i < totalSegments; i++) {
  //   if ((status = NT_NetTxRelease(hNetTx, netBufs[i])) != NT_SUCCESS) {
  //       // Get the status code as text
  //       NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
  //       fprintf(stderr, "NT_NetTxRelease() failed: %s\n", errorBuffer);
  //       return -1;
  //   }
  // }

  // Get segments from the file and transmit them to defined port
  while (appRunning == 1) {
    for (uint32_t i = 0; i < totalSegments; i++) {

      // Get a TX buffer for this segment
      do {
        uint64_t segmentLen = i + 1 == totalSegments ? last_segment_length : segment_length;
        status = NT_NetTxGet(hNetTx, &hNetBufTx, (uint32_t)opt_port, segmentLen, NT_NETTX_SEGMENT_OPTION_RAW, 100);

        if ((status != NT_SUCCESS) && (status != NT_STATUS_TIMEOUT)) {
          // Get the status code as text
          NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
          fprintf(stderr, "NT_NetFileGet() failed: %s\n", errorBuffer);
          goto ExitError;
        }
      } while (status == NT_STATUS_TIMEOUT);

      if (i == 0) {
        NT_NET_SET_PKT_TXSETCLOCK(hNetBufTx, 1);
      }

      // Release the TX buffer and the packets within the segment will be transmitted
      if ((status = NT_NetTxRelease(hNetTx, hNetBufTx)) != NT_SUCCESS) {
        // Get the status code as text
        NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
        fprintf(stderr, "NT_NetTxRelease() failed: %s\n", errorBuffer);
        goto ExitError;
      }
    }
  }

  // Close the TX stream
  NT_NetTxClose(hNetTx);

  // Disable transmit on timestamp
  configWrite.parm = NT_CONFIG_PARM_PORT_TRANSMIT_ON_TIMESTAMP;
  configWrite.u.transmitOnTimestamp.portNo = (uint8_t) opt_port;
  configWrite.u.transmitOnTimestamp.data.timeDelta = 0;
  configWrite.u.transmitOnTimestamp.data.enable = false;
  configWrite.u.transmitOnTimestamp.data.forceTxOnTs = false;
  if ((status = NT_ConfigWrite(hConfig, &configWrite)) != NT_SUCCESS) {
    NT_ExplainError(status, errorBuffer, sizeof(errorBuffer));
    fprintf(stderr, "NT_ConfigWrite() failed: %s\n", errorBuffer);
    NT_ConfigClose(hConfig);
    goto ExitError;
  }

  // Close the config stream
  NT_ConfigClose(hConfig);

  free(netBufs);
  return 0;

ExitError:
  if (netBufs) {
    free(netBufs);
  }
  return -1;
}