rsyslog/tests/inputfilegen.c

/* generate an input file suitable for use by the testbench
 * Copyright (C) 2018-2022 by Rainer Gerhards and Adiscon GmbH.
 * Copyright (C) 2016-2018 by Pascal Withopf and Adiscon GmbH.
 *
 * usage: ./inputfilegen num-lines > file
 * -m number of messages
 * -i start number of message
 * -d extra data to add (all 'X' after the msgnum)
 * -s size of file to generate
 *  cannot be used together with -m
 *  size may be slightly smaller in order to be able to write
 *  the last complete line.
 * -M "message count file" - contains number of messages to be written
 *  This is especially useful with -s, as the testbench otherwise does
 *  not know how to do a seq_check. To keep things flexible, can also be
 *  used with -m (this may aid testbench framework generalization).
 * -f outputfile
 *  Permits to write data to file "outputfile" instead of stdout. Also
 *  enables support for SIGHUP.
 * -S sleep time
 *  ms to sleep between sending message bulks (bulks size given by -B)
 * -B number of messages in bulk
 *  number of messages to send without sleeping as specified in -S.
 *  IGNORED IF -S is not also given!
 * Part of rsyslog, licensed under ASL 2.0
 */
#include "config.h"
#include <stdio.h>
#include <signal.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#if defined(_AIX)
    #include <unistd.h>
#else
    #include <getopt.h>
#endif
#if defined(__FreeBSD__)
    #include <sys/time.h>
#else
    #include <time.h>
#endif
#if defined(HAVE_SYS_SELECT_H)
    #include <sys/select.h>
#endif

#define DEFMSGS 5
#define NOEXTRADATA -1

static volatile int bHadHUP = 0;
static void hdlr_sighup(int sig) {
    fprintf(stderr, "inputfilegen: had hup, sig %d\n", sig);
    bHadHUP = 1;
}
static void sighup_enable() {
    struct sigaction sigAct;
    memset(&sigAct, 0, sizeof(sigAct));
    sigemptyset(&sigAct.sa_mask);
    sigAct.sa_handler = hdlr_sighup;
    sigaction(SIGHUP, &sigAct, NULL);
}

void msleep(const int sleepTime) {
    struct timeval tvSelectTimeout;

    tvSelectTimeout.tv_sec = sleepTime / 1000;
    tvSelectTimeout.tv_usec = (sleepTime % 1000) * 1000; /* micro seconds */
    if (select(0, NULL, NULL, NULL, &tvSelectTimeout) == -1) {
        if (errno != EINTR) {
            perror("select");
            exit(1);
        }
    }
}

static FILE *open_output(const char *fn) {
    FILE *fh_output = fopen(fn, "w");
    if (fh_output == NULL) {
        perror(fn);
        exit(1);
    }
    return fh_output;
}

int main(int argc, char *argv[]) {
    int c, i;
    long long nmsgs = DEFMSGS;
    long long nmsgstart = 0;
    int nfinishedidle = 0;
    int nchars = NOEXTRADATA;
    int errflg = 0;
    long long filesize = -1;
    char *extradata = NULL;
    const char *msgcntfile = NULL;
    const char *outputfile = "-";
    FILE *fh_output;
    int sleep_ms = 0; /* How long to sleep between message writes */
    int sleep_msgs = 0; /* messages to xmit between sleeps (if configured) */
    int sleep_hubreopen_ms = 5; /* Wait until new file is being reopened, logrotate may need some time */
    int ctr = 0;

    while ((c = getopt(argc, argv, "m:M:i:I:h:d:s:f:S:B:")) != -1) {
        switch (c) {
            case 'm':
                nmsgs = atoi(optarg);
                break;
            case 'M':
                msgcntfile = optarg;
                break;
            case 'i':
                nmsgstart = atoi(optarg);
                break;
            case 'I':
                nfinishedidle = atoi(optarg);
                break;
            case 'd':
                nchars = atoi(optarg);
                break;
            case 's':
                filesize = atoll(optarg);
                break;
            case 'S':
                sleep_ms = atoi(optarg);
                break;
            case 'B':
                sleep_msgs = atoi(optarg);
                break;
            case 'h':
                sleep_hubreopen_ms = atoi(optarg);
                break;
            case 'f':
                outputfile = optarg;
                sighup_enable();
                break;
            case ':':
                fprintf(stderr, "Option -%c requires an operand\n", optopt);
                errflg++;
                break;
            case '?':
                fprintf(stderr, "inputfilegen: Unrecognized option: -%c\n", optopt);
                errflg++;
                break;
        }
    }
    if (errflg) {
        fprintf(stderr, "invalid call\n");
        exit(2);
    }

    if (filesize != -1) {
        const int linesize = (17 + nchars); /* 17 is std line size! */
        nmsgs = filesize / linesize;
        fprintf(stderr,
                "inputfilegen: file size requested %lld, actual %lld with "
                "%lld lines, %lld bytes less\n",
                filesize, nmsgs * linesize, nmsgs, filesize - nmsgs * linesize);
        if (nmsgs > 100000000) {
            fprintf(stderr,
                    "inputfilegen: number of lines exhaust 8-digit line numbers "
                    "which are standard inside the testbench.\n"
                    "Use -d switch to add extra data (e.g. -d111 for "
                    "128 byte lines or -d47 for 64 byte lines)\n");
            exit(1);
        }
    }

    if (msgcntfile != NULL) {
        FILE *const fh = fopen(msgcntfile, "w");
        if (fh == NULL) {
            perror(msgcntfile);
            exit(1);
        }
        fprintf(fh, "%lld", nmsgs);
        fclose(fh);
    }

    if (strcmp(outputfile, "-")) {
        fh_output = open_output(outputfile);
    } else {
        fh_output = stdout;
    }

    if (nchars != NOEXTRADATA) {
        extradata = (char *)malloc(nchars + 1);
        memset(extradata, 'X', nchars);
        extradata[nchars] = '\0';
    }
    for (i = nmsgstart; i < (nmsgs + nmsgstart); ++i) {
        if (sleep_ms > 0 && ctr++ >= sleep_msgs) {
            msleep(sleep_ms);
            ctr = 0;
        }
        if (bHadHUP) {
            fclose(fh_output);
            if (sleep_hubreopen_ms > 0) {
                /* Extra Sleep so logrotate or whatever can take place */
                msleep(sleep_hubreopen_ms);
            }
            fh_output = open_output(outputfile);
            fprintf(stderr, "inputfilegen: %s reopened\n", outputfile);
            fprintf(stderr, "inputfilegen: current message number %d\n", i);
            bHadHUP = 0;
        }
        fprintf(fh_output, "msgnum:%8.8d:", i);
        if (nchars != NOEXTRADATA) {
            fprintf(fh_output, "%s", extradata);
        }
        fprintf(fh_output, "\n");
    }
    if (nfinishedidle > 0) {
        /* Keep process open for nfinishedidle ms */
        for (int x = 0; x < nfinishedidle; ++x) {
            if (bHadHUP) {
                /* Create empty file */
                fh_output = open_output(outputfile);
                fclose(fh_output);
                fprintf(stderr, "inputfilegen: last message number was %d\n", i);
                bHadHUP = 0;
            }
            msleep(1);
        }
    }

    free(extradata);
    return 0;
}