/* $Id$ */

/*

 *   Copyright (c) 2001-2010 Aaron Turner <aturner at synfin dot net>

 *   Copyright (c) 2013-2026 Fred Klassen <tcpreplay.dev at gmail dot com> - AppNeta by Broadcom

 *

 *   The Tcpreplay Suite of tools is free software: you can redistribute it

 *   and/or modify it under the terms of the GNU General Public License as

 *   published by the Free Software Foundation, either version 3 of the

 *   License, or with the authors permission any later version.

 *

 *   The Tcpreplay Suite is distributed in the hope that it will be useful,

 *   but WITHOUT ANY WARRANTY; without even the implied warranty of

 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *   GNU General Public License for more details.

 *

 *   You should have received a copy of the GNU General Public License

 *   along with the Tcpreplay Suite.  If not, see <http://www.gnu.org/licenses/>.

 */

#include "defines.h"

#include "config.h"

#include "common.h"

#include <stdlib.h>

#include <string.h>

#ifdef HAVE_SYS_IOCTL_H

#include <sys/ioctl.h>

#endif

/**

 * this is wrapped up in a #define safe_malloc

 * This function, detects failures to malloc memory and zeros out the

 * memory before returning

 */

void *

our_safe_malloc(size_t len, const char *funcname, int line, const char *file)

{

    u_char *ptr;

    if ((ptr = malloc(len)) == NULL) {

        fprintf(stderr, "ERROR in %s:%s() line %d: Unable to malloc() %zu bytes/n", file, funcname, line, len);

        exit(-1);

    }

    /* zero memory */

    memset(ptr, 0, len);

    /* wrapped inside an #ifdef for better performance */

    dbgx(5, "Malloc'd %zu bytes in %s:%s() line %d", len, file, funcname, line);

    return (void *)ptr;

}

/**

 * this is wrapped up in a #define safe_realloc

 * This function, detects failures to realloc memory and zeros

 * out the NEW memory if len > current len.  As always, remember

 * to use it as:

 * ptr = safe_realloc(ptr, size)

 */

void *

our_safe_realloc(void *ptr, size_t len, const char *funcname, int line, const char *file)

{

    if ((ptr = realloc(ptr, len)) == NULL) {

        fprintf(stderr,

                "ERROR: in %s:%s() line %d: Unable to remalloc() buffer to %zu bytes",

                file,

                funcname,

                line,

                len);

        exit(-1);

    }

    dbgx(5, "Remalloc'd buffer to %zu bytes in %s:%s() line %d", len, file, funcname, line);

    return ptr;

}

/**

 * this is wrapped up in a #define safe_strdup

 * This function, detects failures to realloc memory

 */

char *

our_safe_strdup(const char *str, const char *funcname, int line, const char *file)

{

    char *newstr;

    if ((newstr = (char *)malloc(strlen(str) + 1)) == NULL) {

        fprintf(stderr, "ERROR in %s:%s() line %d: Unable to strdup() %zu bytes\n", file, funcname, line, strlen(str));

        exit(-1);

    }

    memcpy(newstr, str, strlen(str) + 1);

    return newstr;

}

pcap_t*

tcpr_pcap_open(const char *path, char *ebuf)

{

#ifdef HAVE_PCAP_OPEN_OFFLINE_WITH_TSTAMP_PRECISION

    return pcap_open_offline_with_tstamp_precision(path, PCAP_TSTAMP_PRECISION_NANO, ebuf);

#else

    return pcap_open_offline(path, ebuf);

#endif

}

/**

 * Returns the native timestamp precision of a capture file:

 * PCAP_TSTAMP_PRECISION_NANO for nanosecond pcap files and for pcapng files

 * (whose interfaces may use nanosecond resolution - opening those at

 * nanosecond precision never loses accuracy), PCAP_TSTAMP_PRECISION_MICRO

 * for everything else, including stdin ("-") which cannot be peeked (#621)

 */

int

tcpr_pcap_file_precision(const char *path)

{

#ifdef HAVE_PCAP_OPEN_OFFLINE_WITH_TSTAMP_PRECISION

    FILE *fp;

    uint32_t magic = 0;

    size_t nread;

    if (path == NULL || strcmp(path, "-") == 0) {

        return PCAP_TSTAMP_PRECISION_MICRO;

    }

    if ((fp = fopen(path, "rb")) == NULL) {

        return PCAP_TSTAMP_PRECISION_MICRO;

    }

    nread = fread(&magic, 1, sizeof(magic), fp);

    fclose(fp);

    if (nread != sizeof(magic)) {

        return PCAP_TSTAMP_PRECISION_MICRO;

    }

    switch (magic) {

    case 0xa1b23c4d: /* nanosecond pcap */

    case 0x4d3cb2a1: /* nanosecond pcap, byte-swapped */

    case 0x0a0d0d0a: /* pcapng section header block */

        return PCAP_TSTAMP_PRECISION_NANO;

    default:

        return PCAP_TSTAMP_PRECISION_MICRO;

    }

#else

    (void)path;

    return 0;

#endif

}

/**

 * calls free and sets to NULL.

 */

void

our_safe_free(void *ptr, const char *funcname, int line, const char *file)

{

    assert(funcname);

    assert(line);

    assert(file);

    if (ptr == NULL)

        return;

    free(ptr);

}

/**

 * get next packet in pcap file

 */

u_char *

our_safe_pcap_next(pcap_t *pcap, struct pcap_pkthdr *pkthdr, const char *funcname, int line, const char *file)

{

    u_char *pktdata = (u_char *)pcap_next(pcap, pkthdr);

    if (pktdata) {

        if (pkthdr->len > MAX_SNAPLEN) {

            fprintf(stderr,

                    "safe_pcap_next ERROR: Invalid packet length in %s:%s() line %d: %u is greater than maximum %u\n",

                    file,

                    funcname,

                    line,

                    pkthdr->len,

                    MAX_SNAPLEN);

            exit(-1);

        }

        if (!pkthdr->len || !pkthdr->caplen) {

            fprintf(stderr,

                    "safe_pcap_next ERROR: Invalid packet length in %s:%s() line %d: packet length=%u capture length=%u\n",

                    file,

                    funcname,

                    line,

                    pkthdr->len,

                    pkthdr->caplen);

            exit(-1);

        }

        /* attempt to correct invalid captures */

        if (pkthdr->len < pkthdr->caplen) {

            dbgx(1, "Correcting invalid packet capture length %d: packet length=%u", pkthdr->caplen, pkthdr->len);

            pkthdr->caplen = pkthdr->len;

        }

    } else {

        /* this will be reported as a failed packet in final report */

        dbg(1, "No data found in packet");

    }

    return pktdata;

}

/**

 * get next packet in pcap file (extended)

 */

int

our_safe_pcap_next_ex(pcap_t *pcap,

                      struct pcap_pkthdr **pkthdr,

                      const u_char **pktdata,

                      const char *funcname,

                      int line,

                      const char *file)

{

    int res = pcap_next_ex(pcap, pkthdr, pktdata);

    if (*pktdata && *pkthdr) {

        if ((*pkthdr)->len > MAXPACKET) {

            fprintf(stderr,

                    "safe_pcap_next_ex ERROR: Invalid packet length in %s:%s() line %d: %u is greater than maximum %u\n",

                    file,

                    funcname,

                    line,

                    (*pkthdr)->len,

                    MAXPACKET);

            exit(-1);

        }

        if (!(*pkthdr)->len || (*pkthdr)->len < (*pkthdr)->caplen) {

            fprintf(stderr,

                    "safe_pcap_next_ex ERROR: Invalid packet length in %s:%s() line %d: packet length=%u capture length=%u\n",

                    file,

                    funcname,

                    line,

                    (*pkthdr)->len,

                    (*pkthdr)->caplen);

            exit(-1);

        }

        if ((*pkthdr)->len < (*pkthdr)->caplen) {

            dbgx(1, "Correcting invalid packet capture length %d: packet length=%u", (*pkthdr)->caplen, (*pkthdr)->len);

            (*pkthdr)->caplen = (*pkthdr)->len;

        }

    } else {

        /* this will be reported as a failed packet in final report */

        dbgx(1, "No data found in packet 0x%p and/or header 0x%p", *pktdata, *pkthdr);

    }

    return res;

}

/**

 * Print various packet statistics

 */

void

packet_stats(const tcpreplay_stats_t *stats)

{

    struct timespec diff;

    COUNTER diff_us;

    COUNTER bytes_sec = 0;

    u_int32_t bytes_sec_10ths = 0;

    COUNTER mb_sec = 0;

    u_int32_t mb_sec_100ths = 0;

    u_int32_t mb_sec_1000ths = 0;

    COUNTER pkts_sec = 0;

    u_int32_t pkts_sec_100ths = 0;

    timessub(&stats->end_time, &stats->start_time, &diff);

    diff_us = TIMESPEC_TO_MICROSEC(&diff);

    if (diff_us && stats->pkts_sent && stats->bytes_sent) {

        COUNTER bytes_sec_X10;

        COUNTER pkts_sec_X100;

        COUNTER mb_sec_X1000;

        COUNTER mb_sec_X100;

        if (stats->bytes_sent > 1000 * 1000 * 1000 && diff_us > 1000 * 1000) {

            bytes_sec_X10 = (stats->bytes_sent * 10 * 1000) / (diff_us / 1000);

            pkts_sec_X100 = (stats->pkts_sent * 100 * 1000) / (diff_us / 1000);

        } else {

            bytes_sec_X10 = (stats->bytes_sent * 10 * 1000 * 1000) / diff_us;

            pkts_sec_X100 = (stats->pkts_sent * 100 * 1000 * 1000) / diff_us;

        }

        bytes_sec = bytes_sec_X10 / 10;

        bytes_sec_10ths = bytes_sec_X10 % 10;

        mb_sec_X1000 = (bytes_sec * 8) / 1000;

        mb_sec_X100 = mb_sec_X1000 / 10;

        mb_sec = mb_sec_X1000 / 1000;

        mb_sec_100ths = mb_sec_X100 % 100;

        mb_sec_1000ths = mb_sec_X1000 % 1000;

        pkts_sec = pkts_sec_X100 / 100;

        pkts_sec_100ths = pkts_sec_X100 % 100;

    }

    if (diff_us >= 1000 * 1000) {

        printf("Actual: " COUNTER_SPEC " packets (" COUNTER_SPEC " bytes) sent in %zd.%02zd seconds\n",

               stats->pkts_sent,

               stats->bytes_sent,

               (ssize_t)diff.tv_sec,

               (ssize_t)(diff.tv_nsec / (10 * 1000000)));

    } else {

        printf("Actual: " COUNTER_SPEC " packets (" COUNTER_SPEC " bytes) sent in %zd.%06zd seconds\n",

               stats->pkts_sent,

               stats->bytes_sent,

               (ssize_t)diff.tv_sec,

               (ssize_t)diff.tv_nsec / 1000);

    }

    if (mb_sec >= 1)

        printf("Rated: %llu.%1u Bps, %llu.%02u Mbps, %llu.%02u pps\n",

               bytes_sec,

               bytes_sec_10ths,

               mb_sec,

               mb_sec_100ths,

               pkts_sec,

               pkts_sec_100ths);

    else

        printf("Rated: %llu.%1u Bps, %llu.%03u Mbps, %llu.%02u pps\n",

               bytes_sec,

               bytes_sec_10ths,

               mb_sec,

               mb_sec_1000ths,

               pkts_sec,

               pkts_sec_100ths);

    fflush(NULL);

    if (stats->failed)

        printf("Failed write attempts: " COUNTER_SPEC "\n", stats->failed);

}

/**

 * fills a buffer with a string representing the given time

 *

 * @param when: the time that should be formatted

 * @param buf: a buffer to write to

 * @param len: length of the buffer

 * @return: string containing date, or -1 on error

 */

int

format_date_time(struct timespec *when, char *buf, size_t len)

{

    struct tm *tm;

    char tmp[64];

    assert(len);

    tm = localtime(&when->tv_sec);

    if (!tm)

        return -1;

    strftime(tmp, sizeof tmp, "%Y-%m-%d %H:%M:%S.%%09u", tm);

    return snprintf(buf, len, tmp, when->tv_nsec);

}

/**

 * reads a hexstring in the format of xx,xx,xx,xx spits it back into *hex

 * up to hexlen bytes.  Returns actual number of bytes returned.  On error

 * it just calls errx() since all errors are fatal.

 */

int

read_hexstring(const char *l2string, u_char *hex, int hexlen)

{

    int numbytes = 0;

    unsigned int value;

    char *l2byte;

    u_char databyte;

    char *token = NULL;

    char *string;

    string = safe_strdup(l2string);

    if (hexlen <= 0)

        err(-1, "Hex buffer must be > 0");

    memset(hex, '\0', hexlen);

    /* data is hex, comma separated, byte by byte */

    /* get the first byte */

    l2byte = strtok_r(string, ",", &token);

    if (l2byte == NULL)

        err(-1, "Hex buffer must contain something");

    value = strtol(l2byte, NULL, 16);

    if (value > 0xff)

        errx(-1, "Invalid hex string byte: %s", l2byte);

    databyte = (u_char)value;

    memcpy(&hex[numbytes], &databyte, 1);

    /* get remaining bytes */

    while ((l2byte = strtok_r(NULL, ",", &token)) != NULL) {

        numbytes++;

        if (numbytes + 1 > hexlen) {

            warn("Hex buffer too small for data- skipping data");

            goto done;

        }

        value = strtol(l2byte, NULL, 16);

        if (value > 0xff)

            errx(-1, "Invalid hex string byte: %s", l2byte);

        databyte = (u_char)value;

        memcpy(&hex[numbytes], &databyte, 1);

    }

    numbytes++;

done:

    safe_free(string);

    dbgx(1, "Read %d bytes of hex data", numbytes);

    return (numbytes);

}

#ifdef USE_CUSTOM_INET_ATON

int

inet_aton(const char *name, struct in_addr *addr)

{

    in_addr_t a = inet_addr(name);

    addr->s_addr = a;

    return a != (in_addr_t)-1;

}

#endif

#if SIZEOF_LONG == 4

uint32_t

__div64_32(uint64_t *n, uint32_t base)

{

    uint64_t rem = *n;

    uint64_t b = base;

    uint64_t res, d = 1;

    uint32_t high = rem >> 32;

    /* Reduce the thing a bit first */

    res = 0;

    if (high >= base) {

        high /= base;

        res = (uint64_t)high << 32;

        rem -= (uint64_t)(high * base) << 32;

    }

    while ((int64_t)b > 0 && b < rem) {

        b = b + b;

        d = d + d;

    }

    do {

        if (rem >= b) {

            rem -= b;

            res += d;

        }

        b >>= 1;

        d >>= 1;

    } while (d);

    *n = res;

    return rem;

}

#endif /* SIZEOF_LONG  == 4 */

/**

 * Implementation of rand_r that is consistent across all platforms

 * This algorithm is mentioned in the ISO C standard, here extended

 * for 32 bits.

 * @param: seed

 * @return: random number

 */

uint32_t

tcpr_random(uint32_t *seed)

{

    unsigned int next = *seed;

    unsigned int result;

    next *= 1103515245;

    next += 12345;

    result = (int)(next / 65536) % 2048;

    next *= 1103515245;

    next += 12345;

    result <<= 10;

    result ^= (int)(next / 65536) % 1024;

    next *= 1103515245;

    next += 12345;

    result <<= 10;

    result ^= (int)(next / 65536) % 1024;

    *seed = next;

    return result;

}

/**

 * #416 - Ensure STDIN is not left in non-blocking mode after closing

 * a program. BSD and Unix derivatives should utilize `FIONBIO` due to known

 * issues with reading from tty with a 0 byte read returning -1 opposed to 0.

 */

void

restore_stdin(void)

{

#ifdef FIONBIO

    int nb = 0;

    ioctl(0, FIONBIO, &nb);

#else

    fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);

#endif /* FIONBIO */

}