clamav/unit_tests/check_bytecode.c

/*
 *  Unit tests for bytecode functions. 
 *
 *  Copyright (C) 2009 Sourcefire, Inc.
 *
 *  Authors: Török Edvin
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 *
 *  This program 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 this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 *  MA 02110-1301, USA.
 */
#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif

#include <stdio.h>

#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <check.h>
#include "../libclamav/clamav.h"
#include "../libclamav/others.h"
#include "../libclamav/bytecode.h"
#include "checks.h"
#include "../libclamav/dconf.h"
#include "../libclamav/bytecode_priv.h"

static void runtest(const char *file, uint64_t expected, int fail, int nojit)
{
    int rc;
    int fd = open_testfile(file);
    FILE *f;
    struct cli_bc bc;
    struct cli_bc_ctx *ctx;
    struct cli_all_bc bcs;
    uint64_t v;

    fail_unless(fd >= 0, "retmagic open failed");
    f = fdopen(fd, "r");
    fail_unless(!!f, "retmagic fdopen failed");

    cl_debug();

    if (!nojit) {
	rc = cli_bytecode_init(&bcs, BYTECODE_ENGINE_MASK);
	fail_unless(rc == CL_SUCCESS, "cli_bytecode_init failed");
    } else {
	bcs.engine = NULL;
    }

    bcs.all_bcs = &bc;
    bcs.count = 1;

    rc = cli_bytecode_load(&bc, f, NULL, 1);
    fail_unless(rc == CL_SUCCESS, "cli_bytecode_load failed");
    fclose(f);

    rc = cli_bytecode_prepare(&bcs, BYTECODE_ENGINE_MASK);
    fail_unless(rc == CL_SUCCESS, "cli_bytecode_prepare failed");

    if (have_clamjit && !nojit && nojit != -1) {
	fail_unless(bc.state == bc_jit, "preparing for JIT failed");
    }

    ctx = cli_bytecode_context_alloc();
    /* small timeout, these bytecodes are fast! */
    ctx->bytecode_timeout = 100000;
    fail_unless(!!ctx, "cli_bytecode_context_alloc failed");

    cli_bytecode_context_setfuncid(ctx, &bc, 0);
    rc = cli_bytecode_run(&bcs, &bc, ctx);
    fail_unless_fmt(rc == fail, "cli_bytecode_run failed, expected: %u, have: %u\n",
		    fail, rc);

    if (rc == CL_SUCCESS) {
	v = cli_bytecode_context_getresult_int(ctx);
	fail_unless_fmt(v == expected, "Invalid return value from bytecode run, expected: %llx, have: %llx\n",
			expected, v);
    }
    cli_bytecode_context_destroy(ctx);
    cli_bytecode_destroy(&bc);
    cli_bytecode_done(&bcs);
}

START_TEST (test_retmagic)
{
    cl_init(CL_INIT_DEFAULT);
    runtest("input/retmagic.cbc", 0x1234f00d, CL_SUCCESS, 0);
    runtest("input/retmagic.cbc", 0x1234f00d, CL_SUCCESS, 1);
}
END_TEST

START_TEST (test_arith)
{
    cl_init(CL_INIT_DEFAULT);
    runtest("input/arith.cbc", 0xd5555555, CL_SUCCESS, 0);
    runtest("input/arith.cbc", 0xd5555555, CL_SUCCESS, 1);
}
END_TEST

START_TEST (test_apicalls)
{
    cl_init(CL_INIT_DEFAULT);
    runtest("input/apicalls.cbc", 0xf00d, CL_SUCCESS, 0);
    runtest("input/apicalls.cbc", 0xf00d, CL_SUCCESS, 1);
}
END_TEST

START_TEST (test_apicalls2)
{
    cl_init(CL_INIT_DEFAULT);
    if (have_clamjit)/*FIXME: should work with both */
    runtest("input/apicalls2.cbc", 0xf00d, CL_SUCCESS, 0);
/*    runtest("input/apicalls2.cbc", 0xf00d, CL_SUCCESS, 1); */
}
END_TEST

START_TEST (test_div0)
{
    cl_init(CL_INIT_DEFAULT);
    /* must not crash on div#0 but catch it */
    runtest("input/div0.cbc", 0, CL_EBYTECODE, 0);
    runtest("input/div0.cbc", 0, CL_EBYTECODE, 1);
}
END_TEST

START_TEST (test_lsig)
{
    cl_init(CL_INIT_DEFAULT);
#if 0
FIXME: match_counts should be initialized in clambc mode
    if (have_clamjit)/* FIXME: should work with both */
    runtest("input/lsig.cbc", 0, 0, 0);
  //runtest("input/lsig.cbc", 0, CL_EBYTECODE, 1);
#endif
}
END_TEST

START_TEST (test_inf)
{
    cl_init(CL_INIT_DEFAULT);
    if (have_clamjit)
	runtest("input/inf.cbc", 0, CL_ETIMEOUT, 0);
}
END_TEST

Suite *test_bytecode_suite(void)
{
    Suite *s = suite_create("bytecode");
    TCase *tc_cli_arith = tcase_create("arithmetic");
    suite_add_tcase(s, tc_cli_arith);

    tcase_add_test(tc_cli_arith, test_retmagic);
    tcase_add_test(tc_cli_arith, test_arith);
    tcase_add_test(tc_cli_arith, test_apicalls);
    tcase_add_test(tc_cli_arith, test_apicalls2);
    tcase_add_test(tc_cli_arith, test_div0);
    tcase_add_test(tc_cli_arith, test_lsig);
    tcase_add_test(tc_cli_arith, test_inf);
    return s;
}