10_transmit_buffered_transmitter_f.c

This example shows how to use bRAWcap to transmit packets using a buffered approach.

The example demonstrates how to create a buffer, fill it with packets, and transmit the entire buffer over the network. The buffered approach allows for more efficient transmission of multiple packets at once.

/**
 * @file 10_transmit_buffered_transmitter_f.c
 *
 * @brief bRAWcap Example - Demonstrates how to transmit packets using a buffered approach.
 *
 * @version 1.0
 *
 * @date 2025-10-08
 *
 * HISTORY:
 * - 2025-10-08: Initial version
 *
 * @copyright
 * <b> © 2021 - b-plus technologies GmbH. All rights reserved!</b>
 *
 * All rights exclusively reserved for b-plus GmbH, unless expressly otherwise agreed.
 *
 * Redistribution in source or any other form, with or without modification, is not permitted.
 *
 * You may use this code under the according license terms of b-plus.
 * Please contact b-plus at services@b-plus.com to get the appropriate terms and conditions.
 */
// Include bRAWcap
// Include bRAWcap
#include "libbrawcap.h"
 
// C STD
#include <stdio.h> // for printf
#include <stdlib.h> // for strtol
#include <time.h> // for time
 
typedef struct receive_counters
{
    unsigned long long packets;
    unsigned long long bytes;
}receive_counters_t;
 
typedef struct example_context
{
    unsigned char demoLogged;
    receive_counters_t counters;
}example_context_t;
 
 
BOOL g_transmission_pending = FALSE;
 
// Check command line parameters if a custom execution time is specified
void ParseArgs(int argc, char** argv, int* exec_time)
{
    if(argc > 1)
    {
        if(!memcmp(argv[1], "-t", 2))
        {
            char* pEnd = 0;
            *exec_time = strtol(argv[2], &pEnd,0);
        }
    }
}
 
// Transmit callback function
// This function will be called when the transmission is done
static void tx_callback(brawcap_handle_t* const pHandle, const brawcap_status_t status,
    brawcap_buffer_t* const pBuffer, void* pUser)
{
    UINT32 length = 0;
    char* friendlyName = 0;
    brawcap_adapter_name_t name;
    if (brawcap_adapter_friendly_name_by_handle(pHandle, 0, &length) == BRAWCAP_STATUS_ERROR_OVERRUN)
    {
        friendlyName = (char*)malloc(length);
        brawcap_adapter_friendly_name_by_handle(pHandle, 0, &length);
    }
    else {
        brawcap_adapter_name_by_handle(pHandle, name);
    }
 
    if (BRAWCAP_SUCCESS(status)) {
        brawcap_buffer_packet_count_t numPackets;
        brawcap_buffer_count(pBuffer, &numPackets);
        printf("[INFO] %s: Transmission successful (Packets: %u)\n", friendlyName ? friendlyName : name, numPackets);
    }
    else {
        printf("[WARNING] %s: Transmission failed with status 0x%04x.\n", friendlyName ? friendlyName : name, status);
    }
    if (friendlyName)
    {
        free(friendlyName);
    }
 
    g_transmission_pending = FALSE;
}
 
int main(int argc, char** argv)
{
    // Set console title
    SetConsoleTitleA("bRAWcap Example - Buffered Transmitter");
 
    int exec_time = 300; // 5 minutes
    time_t startup_sec = time(NULL);
    ParseArgs(argc, argv, &exec_time);
 
    // Some generic helper locals...
    int retVal = 0;
    example_context_t context = {0};
 
    // Here we will store the status of any bRAWcap function
    brawcap_status_t status = BRAWCAP_STATUS_SUCCESS;
 
    // Here we store the number of available bRAWcap adapters
    brawcap_adapter_count_t numberAdapters = 0;
    // This will contain our bRAWcap handle to the adapter we want to receive from
    brawcap_handle_t* pHandle = 0;
    // Our local packet buffer we will fill with packets to transmit
    brawcap_buffer_t* pPacketBuffer = 0;
    do
    {
        // First check if we have any bRAWcap adapters available.
        // --> This function can only fail if we did something wrong.
        //     But we are sure that we did everything right...
        //     therefore we do not check it�s status.
        brawcap_adapter_list_count(&numberAdapters);
 
        // No adapters... nothing do receive from... lets exit ...
        if (!numberAdapters)
        {
            printf("[WARNING] No bRAWcap adapter available... Will stop now.");
            break;
        }
 
        // Get the name of the first adapter.
        // To not overload the example with complex stuff,
        // we always go for the first available adapter.
        brawcap_adapter_name_t name = { '\0' };
        if (!BRAWCAP_SUCCESS(brawcap_adapter_list_at(0, name)))
        {
            printf("[ERROR] Unexpected status while retrieving adapter name: %d", brawcap_last_status());
            retVal = -1;
            break;
        }
 
        // Open a handle to the adapter by using the retrieved name.
        if (!BRAWCAP_SUCCESS(brawcap_open(name, &pHandle)))
        {
            printf("[ERROR] Unexpected status while opening handle: %d", brawcap_last_status());
            retVal = -1;
            break;
        }
 
        // Create the packet buffers
        if(!BRAWCAP_SUCCESS(brawcap_buffer_create(&pPacketBuffer, BRAWCAP_PACKET_SIZE_MAX, 5)))
        {
            printf("[ERROR] Unexpected status while creating packet buffer: %d", brawcap_last_status());
            retVal = -1;
            break;
        }
 
        // Fill the packet buffer with some packets to transmit
        brawcap_buffer_iterator_t* pIterator = 0;
        brawcap_buffer_iterator_create(&pIterator, pPacketBuffer, 0);
 
        brawcap_packet_t* pPacket = 0;
        brawcap_packet_create(&pPacket, BRAWCAP_PACKET_SIZE_MAX);
        // Define the payload as a byte array
        unsigned char payload[] = {
            0x68, 0xB9, 0x83, 0x01, 0x7b, 0xff, 0x68, 0xB9, 0x83, 0x01, 0x36, 0xff, 0x08, 0x00,
            0x45, 0x00, 0x04, 0x1c, 0xff, 0x6c, 0x00, 0x00, 0xff, 0x11, 0xff, 0x10, 0xff, 0xff,
            0x06, 0x02, 0xC0, 0xA8, 0x06, 0x01, 0xff, 0xff, 0x1f, 0x90, 0x04, 0x08, 0x58, 0x24
        };
        // Set the payload of the packet
        brawcap_packet_payload_set_v2(pPacket, payload, sizeof(payload));
 
        for(int i = 0; i < 5; ++i)
            brawcap_buffer_add_back(pPacketBuffer, pPacket);
 
        // Transmit the packets in the buffer until the execution time is reached
        brawcap_tx_start(pHandle, tx_callback, NULL);
        do
        {
            brawcap_tx_buffer_send(pHandle, pPacketBuffer, FALSE);
            g_transmission_pending = TRUE;
            while(g_transmission_pending)
            {
                // Wait until the transmission is done
                Sleep(500);
            }
        } while (time(NULL) - startup_sec < exec_time);
        brawcap_tx_stop(pHandle);
    }while(0);
 
    // We do not want to produce any memory leaks...
    // ... so always cleanup what we have created
    // --> The functions here can only fail if we did something wrong.
    //     But we are sure that we did everything right...
    //     therefore we do not check their status.
    if (pPacketBuffer)
        brawcap_buffer_free(pPacketBuffer);
    if (pHandle)
        brawcap_close(pHandle);
 
    return retVal;
}