ubgpsuite/tools/bgpgrep/bgpgrep.c

// SPDX-License-Identifier: GPL-3.0-or-later

/**
 * \file bgpgrep.c
 *
 * `bgpgrep` main entry point and general command line parsing.
 *
 * \copyright The DoubleFourteen Code Forge (C) All Rights Reserved
 * \author    Lorenzo Cogotti
 */

#include "bgpgrep_local.h"

#include "bgp/bgp.h"
#include "bgp/bytebuf.h"
#include "bgp/patricia.h"
#include "cpr/flate.h"
#include "cpr/bzip2.h"
#include "cpr/xz.h"
#include "sys/fs.h"
#include "sys/con.h"
#include "sys/sys.h"
#include "sys/vt100.h"
#include "argv.h"
#include "strlib.h"

#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

#define BYTEBUFSIZ (256 * 1024)

static BGP_FIXBYTEBUF(BYTEBUFSIZ) bgp_msgBuf = { BYTEBUFSIZ };

BgpgrepState S;

typedef enum {
	NO_COLOR_FLAG,
	DUMP_BYTECODE_FLAG,

	NUM_FLAGS
} BgpgrepOpt;

static Optflag options[] = {
	[NO_COLOR_FLAG] = {
		'-', "no-color", NULL, "Disable color output", ARG_NONE
	},
	[DUMP_BYTECODE_FLAG] = {
		'-', "dump-bytecode", NULL, "Dump BGP VM bytecode to stderr (debug)", ARG_NONE
	},

	[NUM_FLAGS] = { '\0' }
};

static void Bgpgrep_SetupCommandLine(char *argv0)
{
	Sys_StripPath(argv0, NULL);
	Sys_StripFileExtension(argv0, NULL);

	com_progName   = argv0;
	com_synopsis   = "[OPTIONS...] [FILES...]";
	com_shortDescr = "Filter and print BGP data within MRT dumps";
	com_longDescr  =
		"Reads MRT dumps in various formats, applying filtering rules\n"
		"to each BGP message therein, then outputs every passing message to stdout.\n"
		"If - is found inside FILES, then input is read from stdin.\n"
		"If no FILES arguments are provided, then input\n"
		"is implicitly expected from stdin.\n"
		"Any diagnostic message is logged to stderr.";
}

static void Bgpgrep_ApplyProgramOptions(void)
{
	S.noColor      = options[NO_COLOR_FLAG].flagged;
	S.dumpBytecode = options[DUMP_BYTECODE_FLAG].flagged;
}

static int CountFileArguments(int argc, char **argv)
{
	int i;

	for (i = 0; i < argc; i++) {
		const char *arg = argv[i];
		if (arg[0] == '-' && arg[1] != '\0')
			break;
		if (strcmp(arg, "(") == 0 || strcmp(arg, "!") == 0)
			break;
	}

	return i;
}

void Bgpgrep_Fatal(const char *fmt, ...)
{
	va_list va;

	Sys_Print(STDERR, com_progName);
	Sys_Print(STDERR, ": ERROR: ");

	va_start(va, fmt);
	Sys_VPrintf(STDERR, fmt, va);
	va_end(va);

	Sys_Print(STDERR, "\n");
	exit(EXIT_FAILURE);
}

void Bgpgrep_Warning(const char *fmt, ...)
{
	va_list va;

	Sys_Print(STDERR, com_progName);
	Sys_Print(STDERR, ": ");
	if (S.filename) {
		Sys_Print(STDERR, S.filename);
		Sys_Print(STDERR, ": ");
	}

	Sys_Print(STDERR, "WARNING: ");

	va_start(va, fmt);
	Sys_VPrintf(STDERR, fmt, va);
	va_end(va);

	Sys_Print(STDERR, "\n");
}

void Bgpgrep_DropMessage(const char *fmt, ...)
{
	va_list va;

	Sys_Print(STDERR, com_progName);
	Sys_Print(STDERR, ": ");

	assert(S.filename);
	Sys_Print(STDERR, S.filename);
	Sys_Print(STDERR, ": ");

	va_start(va, fmt);
	Sys_VPrintf(STDERR, fmt, va);
	va_end(va);

	Sys_Print(STDERR, "\n");

	Bgp_ClearMsg(&S.msg);
	S.nerrors++;

	longjmp_fast(S.dropMsgFrame);
}

void Bgpgrep_DropRecord(const char *fmt, ...)
{
	va_list va;

	Sys_Print(STDERR, com_progName);
	Sys_Print(STDERR, ": ");

	assert(S.filename);
	Sys_Print(STDERR, S.filename);
	Sys_Print(STDERR, ": ");

	va_start(va, fmt);
	Sys_VPrintf(STDERR, fmt, va);
	va_end(va);

	Sys_Print(STDERR, "\n");
	S.nerrors++;

	S.lenientBgpErrors = FALSE;  // reset for future files

	// If we're dropping a record we have to kill S.rec and S.msg
	Bgp_ClearMsg(&S.msg);
	Bgp_ClearMrt(&S.rec);

	// ...but don't drop PEER_INDEX_TABLE

	longjmp_fast(S.dropRecordFrame);
}

void Bgpgrep_DropFile(const char *fmt, ...)
{
	va_list va;

	Sys_Print(STDERR, com_progName);
	Sys_Print(STDERR, ": ");

	assert(S.filename);
	Sys_Print(STDERR, S.filename);
	Sys_Print(STDERR, ": ");

	va_start(va, fmt);
	Sys_VPrintf(STDERR, fmt, va);
	va_end(va);

	Sys_Print(STDERR, "\n");
	S.nerrors++;

	S.lenientBgpErrors = FALSE;  // reset for future files

	// Must clear PEER_INDEX_TABLE also, along with S.rec and S.msg...
	Bgp_ClearMsg(&S.msg);
	Bgp_ClearMrt(&S.rec);
	Bgp_ClearMrt(&S.peerIndex);
	S.hasPeerIndex = FALSE;

	longjmp_fast(S.dropFileFrame);
}

// Common error management for BGP layer
NOINLINE static void Bgpgrep_HandleBgpError(BgpRet err, Srcloc *loc, void *obj)
{
	USED(obj);

	if (err == BGPEVMMSGERR)
		err = Bgp_GetErrStat(NULL);  // retrieve the actual BGP error

	// Hopefully we are not dealing with a programming error...
	assert(err != BGPEBADMRTTYPE);
	assert(err != BGPENOADDPATH);
	assert(err != BGPEBADTYPE && err != BGPEBADATTRTYPE);

	// On out of memory we die with an appropriate backtrace
	if (err == BGPENOMEM) {
		loc->call_depth++;  // include this function itself

		_Sys_OutOfMemory(loc->filename, loc->func, loc->line, loc->call_depth);
	}

	// BGP filter errors should never occur, but are theoretically
	// possible when filters are excessively complex,
	// we don't proceed any further since they may cause incomplete or
	// misleading output data
	if (BGP_ISVMERR(err))
		Bgpgrep_Fatal("Unexpected BGP filter error: %s", Bgp_ErrorString(err));

	// On I/O error we drop the entire file
	if (err == BGPEIO)
		Bgpgrep_DropFile("I/O error while reading MRT dump");  // TODO: better diagnostics

	// Deal with critical MRT errors that cause a record drop
	if (err == BGPETRUNCMRT || err == BGPETRUNCPEERV2 || err == BGPETRUNCRIBV2)
		Bgpgrep_DropRecord("SKIPPING MRT RECORD: %s", Bgp_ErrorString(err));

	if (BGP_ISMSGERR(err)) {
		if (S.lenientBgpErrors) {
			// Get away with just a warning
			Bgpgrep_Warning("CORRUPT BGP MESSAGE: %s", Bgp_ErrorString(err));
			S.nerrors++;
			return;
		}

		// Drop the affected entry
		Bgpgrep_DropMessage("SKIPPING BGP MESSAGE: %s", Bgp_ErrorString(err));
	}

	assert(BGP_ISMRTERR(err));

	if (err == BGPEBADPEERIDXCNT || err == BGPEBADRIBV2CNT) {
		// Only warrant a warning
		Bgpgrep_Warning("CORRUPT MRT RECORD: %s", Bgp_ErrorString(err));
		S.nerrors++;
		return;
	}

	// Anything else causes a BGP drop
	Bgpgrep_DropMessage("SKIPPING BGP MESSAGE: %s", Bgp_ErrorString(err));
}

static void Bgpgrep_Init(void)
{
	if (!S.noColor && Sys_IsVt100Console(STDOUT))
		S.outFmt = Bgp_IsolarioFmtWc;  // console supports colors
	else
		S.outFmt = Bgp_IsolarioFmt;

	Mrtrecord *rec = &S.rec;
	Bgpmsg    *msg = &S.msg;

	rec->allocp = msg->allocp = &bgp_msgBuf;
	rec->memOps = msg->memOps =  Mem_BgpBufOps;

	Bgp_InitVm(&S.vm, /*heapSize=*/0);
}

static const StmOps *Bgpgrep_OpenMrtDump(const char *filename, void **phn)
{
	Fildes fh = Sys_Fopen(filename, FM_READ, FH_SEQ);
	if (fh == FILDES_BAD)
		Bgpgrep_DropFile("Can't open file");

	const char *ext = Sys_GetFileExtension(filename);

	void *hn;
	const StmOps *ops;

	if (Df_stricmp(ext, ".bz2") == 0) {
		hn  = Bzip2_OpenDecompress(STM_FILDES(fh), Stm_FildesOps, /*opts=*/NULL);
		ops = Bzip2_StmOps;

		Bzip2Ret err = Bzip2_GetErrStat();
		if (err)
			Bgpgrep_DropFile("Can't read Bz2 archive: %s", Bzip2_ErrorString(err));

	} else if (Df_stricmp(ext, ".gz") == 0 || Df_stricmp(ext, ".z") == 0) {
		hn  = Zlib_InflateOpen(STM_FILDES(fh), Stm_FildesOps, /*opts=*/NULL);
		ops = Zlib_StmOps;

		ZlibRet err = Zlib_GetErrStat();
		if (err)
			Bgpgrep_DropFile("Can't read Zlib archive: %s", Zlib_ErrorString(err));

	} else if (Df_stricmp(ext, ".xz") == 0) {
		hn  = Xz_OpenDecompress(STM_FILDES(fh), Stm_FildesOps, /*opts=*/NULL);
		ops = Xz_StmOps;

		XzRet err = Xz_GetErrStat();
		if (err)
			Bgpgrep_DropFile("Can't read LZMA archive: %s", Xz_ErrorString(err));

	} else {
		// Assume uncompressed file
		hn  = STM_FILDES(fh);
		ops = Stm_FildesOps;
	}

	*phn = hn;
	return ops;
}

static void Bgpgrep_ProcessMrtDump(const char *filename)
{
	void *hn;
	const StmOps *ops;

	S.filename = filename;  // NOTE: Only function that manipulates this

	if (strcmp(filename, "-") == 0) {
		hn  = STM_FILDES(CON_FILDES(STDIN));
		ops = Stm_NcFildesOps;
	} else
		ops = Bgpgrep_OpenMrtDump(filename, &hn);

	setjmp_fast(S.dropRecordFrame);  // NOTE: The ONLY place where this is set
	setjmp_fast(S.dropMsgFrame);     // NOTE: May be set again by specific BgpgrepD_*()
	while (Bgp_ReadMrt(&S.rec, hn, ops) == OK) {
		const Mrthdr *hdr = MRT_HDR(&S.rec);

		switch (hdr->type) {
		case MRT_TABLE_DUMPV2: BgpgrepD_TableDumpv2(); break;
		case MRT_TABLE_DUMP:   BgpgrepD_TableDump();   break;
		case MRT_BGP:          BgpgrepD_Zebra();       break;
		default:
			if (MRT_ISBGP4MP(hdr->type))
				BgpgrepD_Bgp4mp();

			break;
		}
	}

	if (ops->Close)
		ops->Close(hn);

	S.filename = NULL;
}

static int Bgpgrep_CleanupAndExit(void)
{
	assert(!S.hasPeerIndex);  // should have been cleared

	Bgp_ClearVm(&S.vm);

	Trielist *t = S.trieList;
	while (t) {
		Trielist *tn = t->next;

		Pat_Clear(&t->trie);
		free(t);

		t = tn;
	}
	return (S.nerrors > 0) ? EXIT_FAILURE : EXIT_SUCCESS;
}

int main(int argc, char **argv)
{
#ifndef NDEBUG
	Sys_SetErrFunc(SYS_ERR_ABORT, NULL);
#else
	Sys_SetErrFunc(SYS_ERR_QUIT, NULL);
#endif
	Bgp_SetErrFunc(Bgpgrep_HandleBgpError, NULL);

	// Initial program setup
	Bgpgrep_SetupCommandLine(argv[0]);

	int optind = Com_ArgParse(argc, argv, options, /*flags=*/ARG_NOREORD);
	if (optind == OPT_HELP)
		return EXIT_SUCCESS;  // only called to get help...
	if (optind < 0)
		return EXIT_FAILURE;  // can't parse command line

	Bgpgrep_ApplyProgramOptions();

	Bgpgrep_Init();  // initialize according to command line

	// Done with options
	argc -= optind;
	argv += optind;

	// Extrapolate files arguments from argv
	char **files  = argv;
	int    nfiles = CountFileArguments(argc, argv);

	// Move to filtering rules and compile them
	argv += nfiles;
	argc -= nfiles;
	Bgpgrep_CompileVmProgram(argc, argv);

	if (nfiles == 0) {
		// If no FILES are provided, read from stdin
		static const char *const stdinFile[] = { "-" };

		files  = (char **) stdinFile;
		nfiles = ARRAY_SIZE(stdinFile);
	}

	// Files processing
	volatile int i = 0;

	setjmp_fast(S.dropFileFrame);  // NOTE: The ONLY place where this is set
	while (i < nfiles) {
		Bgpgrep_ProcessMrtDump(files[i++]);

		// Don't need PEER_INDEX_TABLE anymore
		Bgp_ClearMrt(&S.peerIndex);
		S.hasPeerIndex = FALSE;
	}

	return Bgpgrep_CleanupAndExit();
}