12_buffer_sorting_f.c

This example shows how to create a bRAWcap packet buffer, fill it with packets, sort the packets inside the buffer by their timestamp or payload and verify the sorting.

/**
 * @file 12_buffer_sorting_f.c
 *
 * @brief bRAWcap Example - Demonstrates how to sort a bRWAcap packet buffer by timestamp or payload.
 *
 * It shows how to:
 * - How to create a bRAWcap packet buffer
 * - How to fill the buffer with packets
 * - How to sort the buffer by timestamp or payload field
 *
 * This example makes use of C only.
 *
 * @version 1.0
 *
 * @date 2025-10-21
 *
 * HISTORY:
 * - 2025-10-21: 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 "libbrawcap.h"
 
 
// C STD
#include <stdlib.h> // for rand, strtol
#include <stdbool.h>
#include <stdint.h> // for uint32_t, uint8_t
#include <stdio.h> // for printf
#include <time.h> // for printing time info
#include <stdbool.h> // for bool type
 
// Helper for microsecond timing
#define TIME_DIFF_MS(start, end) ((double)(end - start) * 1000.0 / CLOCKS_PER_SEC)
 
    // Seqid for payload sorting
struct seqid {
  uint32_t offset;
  uint8_t length; // supported 1, 2, 4 bytes
};
 
// Compare timestamps: returns <0 if a<b, 0 if a==b, >0 if a>b
static int compare_timestamps(brawcap_timestamp_t* a, brawcap_timestamp_t* b) {
    UINT64 a_secs = 0;
    UINT32 a_nsecs = 0;
    UINT64 b_secs = 0;
    UINT32 b_nsecs = 0;
    brawcap_timestamp_value_ns_get(a, &a_secs, &a_nsecs);
    brawcap_timestamp_value_ns_get(b, &b_secs, &b_nsecs);
    UINT64 a_ns = ((UINT64)a_secs * 1000000000ULL) + a_nsecs;
    UINT64 b_ns = ((UINT64)b_secs * 1000000000ULL) + b_nsecs;
    if (a_ns < b_ns) return -1;
    if (a_ns > b_ns) return 1;
    return 0;
}
 
// Compare payload seqid: returns <0 if a<b, 0 if a==b, >0 if a>b
static int compare_seqid(const unsigned char* a, const unsigned char* b, UINT8 length) {
    UINT32 va = 0, vb = 0;
    for (UINT8 i = 0; i < length; ++i) {
        va |= ((UINT32)a[i]) << (8 * i);
        vb |= ((UINT32)b[i]) << (8 * i);
    }
    if (va < vb) return -1;
    if (va > vb) return 1;
    return 0;
}
 
// Verify sort order: type 0=timestamp, 1=payload; order 0=rising, 1=falling
bool verify_sort(brawcap_buffer_t* pBuffer, int type, int order, UINT32 seqid_offset, UINT8 seqid_length) {
    brawcap_buffer_packet_count_t count = 0;
    if (brawcap_buffer_count(pBuffer, &count) != BRAWCAP_STATUS_SUCCESS) {
        printf("[VERIFY] Could not get buffer count!\n");
        return false;
    }
    for (brawcap_buffer_packet_count_t i = 1; i < count; ++i) {
        brawcap_packet_t *pPrev = NULL, *pCurr = NULL;
        if (brawcap_buffer_at_index(pBuffer, i-1, &pPrev) != BRAWCAP_STATUS_SUCCESS ||
            brawcap_buffer_at_index(pBuffer, i, &pCurr) != BRAWCAP_STATUS_SUCCESS) {
            printf("[VERIFY] Could not get packet at index %llu or %llu!\n", (unsigned long long)(i-1), (unsigned long long)i);
            return false;
        }
        int cmp = 0;
        if (type == 0) { // timestamp
            brawcap_timestamp_t *tPrev = NULL, *tCurr = NULL;
            brawcap_packet_timestamp_get(pPrev, &tPrev);
            brawcap_packet_timestamp_get(pCurr, &tCurr);
            cmp = compare_timestamps(tPrev, tCurr);
        } else { // payload seqid
            const unsigned char *payloadPrev = NULL, *payloadCurr = NULL;
            brawcap_packet_size_t lenPrev = 0, lenCurr = 0;
            brawcap_packet_payload_get_v2(pPrev, &payloadPrev, &lenPrev);
            brawcap_packet_payload_get_v2(pCurr, &payloadCurr, &lenCurr);
            if (payloadPrev == NULL || payloadCurr == NULL ||
                seqid_offset + seqid_length > lenPrev || seqid_offset + seqid_length > lenCurr) {
                printf("[VERIFY] Invalid payload or seqid range!\n");
                return false;
            }
            cmp = compare_seqid(payloadPrev + seqid_offset, payloadCurr + seqid_offset, seqid_length);
        }
        if ((order == 0 && cmp > 0) || (order == 1 && cmp < 0)) {
            printf("[VERIFY] Sort error at index %llu!\n", (unsigned long long)i);
            return false;
        }
    }
    return true;
}
 
int main(int argc, char** argv)
{
    // user params
    const uint32_t packet_count = 10000;
    const uint16_t payload_length = 1000;
    const struct seqid seqid = { 520, 8 };
    const bool verify = true;
 
    // Set console title
    SetConsoleTitleA("bRAWcap Example - Packet Buffer Sorting");
 
    // Time tracking
    clock_t t_start, t_end;
    double elapsed_us;
 
    // Seed random number generator
    srand((unsigned int)time(NULL));
 
    // The packet buffer to be sorted
    brawcap_buffer_t* pBuffer = 0;
    // A packet to add to the buffer
    brawcap_packet_t* pPacket = 0;
    // Payload
    unsigned char* pPayload = (unsigned char*)malloc(payload_length);
 
    if(seqid.length != 1 && seqid.length != 2 && seqid.length != 4 && seqid.length != 8) {
        printf("[ERROR] Unsupported seqid length: %u. Supported lengths are 1, 2, 4 or 8 bytes.\n", seqid.length);
        return -1;
    }
 
    printf("[INFO] Configuration: \n");
    printf("\t - Packets: %u\n", packet_count);
    printf("\t - Payload Length: %u\n", payload_length);
    printf("\t - SeqId Offset: %u\n", seqid.offset);
    printf("\t - SeqId Length: %u\n", seqid.length);
 
    // Fill the payload with random data and set seqid
    for (size_t i = 0; i < payload_length; ++i)
    {
        pPayload[i] = (unsigned char)(rand() % 256);
    }
 
 
    // Create a bRAWcap packet buffer
    if(brawcap_buffer_create(&pBuffer, payload_length, packet_count) != BRAWCAP_STATUS_SUCCESS)
    {
        printf("[ERROR] Failed to create bRAWcap packet buffer. Status: %d\n", brawcap_last_status());
        return -1;
    }
    printf("[INFO] Created bRAWcap packet buffer.\n");
 
    // Create a packet to add to the buffer
    if(brawcap_packet_create(&pPacket, payload_length) != BRAWCAP_STATUS_SUCCESS)
    {
        printf("[ERROR] Failed to create bRAWcap packet. Status: %d\n", brawcap_last_status());
        brawcap_buffer_free(pBuffer);
        return -1;
    }
 
    // Fill the buffer with packets
    for(brawcap_buffer_packet_count_t i = 0, seqid_counter = 0; i < packet_count; ++i)
    {
        // Simulate packet data (for demonstration purposes)
        // In a real scenario, you would fill the packet with actual captured data
        brawcap_timestamp_t* pTimestamp;
        brawcap_packet_timestamp_get(pPacket, &pTimestamp);
        struct timespec ts;
        timespec_get(&ts, TIME_UTC);
        brawcap_timestamp_value_ns_set(pTimestamp, ts.tv_sec, ts.tv_nsec);
        // Set seqid in payload
    if (seqid.offset + seqid.length < payload_length)
        {
            uint64_t max_val =
                (seqid.length == 1) ? 0xFF :
                (seqid.length == 2) ? 0xFFFF :
                (seqid.length == 4) ? 0xFFFFFFFF :
                (seqid.length == 8) ? 0xFFFFFFFFFFFFFFFF : 0;
            seqid_counter = (seqid_counter + 1) & max_val;
            for (size_t i = 0; i < seqid.length; ++i) {
                pPayload[seqid.offset + i] = (unsigned char)((seqid_counter >> (8 * i)) & 0xFF);
            }
        }
        // Apply payload to packet
        brawcap_packet_payload_set_v2(pPacket, pPayload, payload_length); // Empty payload for demonstration
        // Add packet to buffer
        if(brawcap_buffer_add_back(pBuffer, pPacket) != BRAWCAP_STATUS_SUCCESS)
        {
            printf("[ERROR] Failed to add packet to buffer. Status: %d\n", brawcap_last_status());
        }
    }
 
 
 
    // Sort the buffer by timestamp (rising)
    t_start = clock();
    if(brawcap_buffer_sort(pBuffer,
        BRAWCAP_BUFFER_SORT_ORDER_RISING,
        BRAWCAP_BUFFER_SORT_TYPE_TIMESTAMP,
        0,
        0,
        BRAWCAP_BUFFER_SORT_ENDIAN_LITTLE)
        != BRAWCAP_STATUS_SUCCESS
    ){
        printf("[ERROR] Failed to sort buffer by timestamp. Status: %d\n", brawcap_last_status());
        return -1;
    }
    t_end = clock();
    elapsed_us = TIME_DIFF_MS(t_start, t_end);
    printf("[INFO] Sorted buffer by timestamp rising order. Time: %.0f ms\n", elapsed_us);
    if (verify) {
      printf("[VERIFY] Timestamp rising: %s\n", verify_sort(pBuffer, 0, 0, seqid.offset, seqid.length) ? "OK" : "FAILED");
    }
 
    // Sort the buffer by timestamp (falling)
    t_start = clock();
    if(brawcap_buffer_sort(pBuffer,
        BRAWCAP_BUFFER_SORT_ORDER_FALLING,
        BRAWCAP_BUFFER_SORT_TYPE_TIMESTAMP,
        0,
        0,
        BRAWCAP_BUFFER_SORT_ENDIAN_LITTLE)
        != BRAWCAP_STATUS_SUCCESS
    ){
        printf("[ERROR] Failed to sort buffer by timestamp. Status: %d\n", brawcap_last_status());
        return -1;
    }
    t_end = clock();
    elapsed_us = TIME_DIFF_MS(t_start, t_end);
    printf("[INFO] Sorted buffer by timestamp falling order. Time: %.0f ms\n", elapsed_us);
    if (verify) {
      printf("[VERIFY] Timestamp falling: %s\n", verify_sort(pBuffer, 0, 1, seqid.offset, seqid.length) ? "OK" : "FAILED");
    }
 
    // Sort the buffer by payload seqid (rising)
    t_start = clock();
    if(brawcap_buffer_sort(pBuffer,
        BRAWCAP_BUFFER_SORT_ORDER_RISING,
        BRAWCAP_BUFFER_SORT_TYPE_PAYLOAD,
        seqid.offset,
        seqid.length,
        BRAWCAP_BUFFER_SORT_ENDIAN_LITTLE)
        != BRAWCAP_STATUS_SUCCESS
    ){
            printf("[ERROR] Failed to sort buffer by payload seqid. Status: %d\n", brawcap_last_status());
            return -1;
    }
    t_end = clock();
    elapsed_us = TIME_DIFF_MS(t_start, t_end);
    printf("[INFO] Sorted buffer by payload seqid (rising order). Time: %.0f ms\n", elapsed_us);
    if (verify) {
      printf("[VERIFY] Payload seqid rising: %s\n", verify_sort(pBuffer, 1, 0, seqid.offset, seqid.length) ? "OK" : "FAILED");
    }
 
    // Sort the buffer by payload seqid (falling)
    t_start = clock();
    if(brawcap_buffer_sort(pBuffer,
        BRAWCAP_BUFFER_SORT_ORDER_FALLING,
        BRAWCAP_BUFFER_SORT_TYPE_PAYLOAD,
        seqid.offset,
        seqid.length,
        BRAWCAP_BUFFER_SORT_ENDIAN_LITTLE)
        != BRAWCAP_STATUS_SUCCESS
    ){
            printf("[ERROR] Failed to sort buffer by payload seqid. Status: %d\n", brawcap_last_status());
            return -1;
    }
    t_end = clock();
    elapsed_us = TIME_DIFF_MS(t_start, t_end);
    printf("[INFO] Sorted buffer by payload seqid (falling order). Time: %.0f ms\n", elapsed_us);
    if (verify) {
      printf("[VERIFY] Payload seqid falling: %s\n", verify_sort(pBuffer, 1, 1, seqid.offset, seqid.length) ? "OK" : "FAILED");
    }
 
    brawcap_buffer_free(pBuffer);
    return 0;
}