void mpool_init()
{
#ifndef DONT_USE_POOL
int i;
for (i = 0; i < POOL_COUNT; ++i)
{
if (gpools_sizes[i])
{
general_pools[i] = mpool_create(gpools_sizes[i]);
}
}
#endif
}
END_TEST
START_TEST (test_ac_scanbuff_allscan) {
struct cli_ac_data mdata;
struct cli_matcher *root;
unsigned int i;
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
root->ac_only = 1;
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_ac_init(root, CLI_DEFAULT_AC_MINDEPTH, CLI_DEFAULT_AC_MAXDEPTH, 1);
fail_unless(ret == CL_SUCCESS, "cli_ac_init() failed");
for(i = 0; ac_testdata[i].data; i++) {
ret = cli_parse_add(root, ac_testdata[i].virname, ac_testdata[i].hexsig, 0, 0, 0, "*", 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "cli_parse_add() failed");
}
ret = cli_ac_buildtrie(root);
fail_unless(ret == CL_SUCCESS, "cli_ac_buildtrie() failed");
ret = cli_ac_initdata(&mdata, root->ac_partsigs, 0, 0, CLI_DEFAULT_AC_TRACKLEN);
fail_unless(ret == CL_SUCCESS, "cli_ac_initdata() failed");
ctx.options |= CL_SCAN_ALLMATCHES;
for(i = 0; ac_testdata[i].data; i++) {
ret = cli_ac_scanbuff((const unsigned char*)ac_testdata[i].data, strlen(ac_testdata[i].data), &virname, NULL, NULL, root, &mdata, 0, 0, NULL, AC_SCAN_VIR, NULL);
fail_unless_fmt(ret == CL_VIRUS, "cli_ac_scanbuff() failed for %s", ac_testdata[i].virname);
fail_unless_fmt(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
ret = cli_scanbuff((const unsigned char*)ac_testdata[i].data, strlen(ac_testdata[i].data), 0, &ctx, 0, NULL);
fail_unless_fmt(ret == CL_VIRUS, "cli_scanbuff() failed for %s", ac_testdata[i].virname);
fail_unless_fmt(!strncmp(virname, ac_testdata[i].virname, strlen(ac_testdata[i].virname)), "Dataset %u matched with %s", i, virname);
if (ctx.num_viruses)
ctx.num_viruses = 0;
}
cli_ac_freedata(&mdata);
}
static void mpool_test004(void){
mpool_t *pool;
pool = mpool_create(0);
const char *cs[] = {"cubicdaiya", "bokko"};
char *s1;
char *s2;
s1 = mpool_alloc(strlen(cs[0]) + 1, pool);
s2 = mpool_alloc(strlen(cs[1]) + 1, pool);
strcpy(s1, cs[0]);
strcpy(s2, cs[1]);
CU_ASSERT(strncmp(s1, cs[0], strlen(s1)) == 0);
CU_ASSERT(strncmp(s2, cs[1], strlen(s2)) == 0);
CU_ASSERT(IS_ALIGNED(s1));
CU_ASSERT(IS_ALIGNED(s2));
mpool_destroy(pool);
}
END_TEST
START_TEST (test_ac_scanbuff_ex) {
struct cli_ac_data mdata;
struct cli_matcher *root;
unsigned int i;
int ret;
root = ctx.engine->root[0];
fail_unless(root != NULL, "root == NULL");
root->ac_only = 1;
#ifdef USE_MPOOL
root->mempool = mpool_create();
#endif
ret = cli_ac_init(root, CLI_DEFAULT_AC_MINDEPTH, CLI_DEFAULT_AC_MAXDEPTH, 1);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_init() failed");
for(i = 0; ac_sigopts_testdata[i].data; i++) {
ret = cli_sigopts_handler(root, ac_sigopts_testdata[i].virname, ac_sigopts_testdata[i].hexsig, ac_sigopts_testdata[i].sigopts, 0, 0, ac_sigopts_testdata[i].offset, 0, NULL, 0);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_sigopts_handler() failed");
}
ret = cli_ac_buildtrie(root);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_buildtrie() failed");
ret = cli_ac_initdata(&mdata, root->ac_partsigs, 0, 0, CLI_DEFAULT_AC_TRACKLEN);
fail_unless(ret == CL_SUCCESS, "[ac_ex] cli_ac_initdata() failed");
for(i = 0; ac_sigopts_testdata[i].data; i++) {
ret = cli_ac_scanbuff((const unsigned char*)ac_sigopts_testdata[i].data, ac_sigopts_testdata[i].dlength, &virname, NULL, NULL, root, &mdata, 0, 0, NULL, AC_SCAN_VIR, NULL);
fail_unless_fmt(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
if (ac_sigopts_testdata[i].expected_result == CL_VIRUS)
fail_unless_fmt(!strncmp(virname, ac_sigopts_testdata[i].virname, strlen(ac_sigopts_testdata[i].virname)), "[ac_ex] Dataset %u matched with %s", i, virname);
ret = cli_scanbuff((const unsigned char*)ac_sigopts_testdata[i].data, ac_sigopts_testdata[i].dlength, 0, &ctx, 0, NULL);
fail_unless_fmt(ret == ac_sigopts_testdata[i].expected_result, "[ac_ex] cli_ac_scanbuff() failed for %s (%d != %d)", ac_sigopts_testdata[i].virname, ret, ac_sigopts_testdata[i].expected_result);
}
cli_ac_freedata(&mdata);
}
MotoPP *motopp_createEnv(char *filename, int flags) {
MotoPP *ppenv;
ppenv = emalloc(sizeof(MotoPP));
ppenv->flags = flags;
ppenv->mpool = mpool_create(10);
ppenv->sysptrs = hset_create(M_SIZE, NULL, NULL, 0);
ppenv->ptrs = hset_create(M_SIZE, NULL, NULL, 0);
ppenv->out = buf_createDefault();
ppenv->err = buf_createDefault();
ppenv->argbuf = buf_createDefault();
ppenv->dirstack = istack_createDefault();
ppenv->macrostack = stack_createDefault();
ppenv->vallist = hset_create(M_SIZE, NULL, NULL, 0);
ppenv->frames = stack_createDefault();
ppenv->frame = motopp_createFrame(ppenv, MAIN_FRAME,filename);
ppenv->mb = NULL;
return ppenv;
}
uint8_t* cli_bcapi_malloc(struct cli_bc_ctx *ctx, uint32_t size)
{
void *v;
#if USE_MPOOL
if (!ctx->mpool) {
ctx->mpool = mpool_create();
if (!ctx->mpool) {
cli_dbgmsg("bytecode: mpool_create failed!\n");
cli_event_error_oom(EV, 0);
return NULL;
}
}
v = mpool_malloc(ctx->mpool, size);
#else
/* TODO: implement using a list of pointers we allocated! */
cli_errmsg("cli_bcapi_malloc not implemented for systems without mmap yet!\n");
v = cli_malloc(size);
#endif
if (!v)
cli_event_error_oom(EV, size);
return v;
}
static void mpool_test003(void){
mpool_t *pool;
pool = mpool_create(16);
bool *b;
short *s;
char *c;
unsigned char *uc;
int *n;
unsigned int *un;
long *l;
unsigned long *ul;
long long *ll;
unsigned long long *ull;
float *f;
double *d;
long double *ld;
time_t *t;
off_t *ot;
intptr_t *ipt;
size_t *siz;
ptrdiff_t *pdt;
b = mpool_alloc(sizeof(*b), pool);
s = mpool_alloc(sizeof(*s), pool);
c = mpool_alloc(sizeof(*c), pool);
uc = mpool_alloc(sizeof(*uc), pool);
n = mpool_alloc(sizeof(*n), pool);
un = mpool_alloc(sizeof(*un), pool);
l = mpool_alloc(sizeof(*l), pool);
ul = mpool_alloc(sizeof(*ul), pool);
ll = mpool_alloc(sizeof(*ll), pool);
ull = mpool_alloc(sizeof(*ull), pool);
f = mpool_alloc(sizeof(*f), pool);
d = mpool_alloc(sizeof(*d), pool);
ld = mpool_alloc(sizeof(*ld), pool);
t = mpool_alloc(sizeof(*t), pool);
ot = mpool_alloc(sizeof(*ot), pool);
ipt = mpool_alloc(sizeof(*ipt), pool);
siz = mpool_alloc(sizeof(*siz), pool);
pdt = mpool_alloc(sizeof(*pdt), pool);
*b = true;
*s = 2;
*c = 'a';
*uc = 'b';
*n = 5;
*un = 255;
*l = 550;
*ul = 333;
*ll = 950;
*ull = 111;
*f = 113.5;
*d = 50.8;
*ld = 115.3;
*t = 123;
*ot = 22;
*ipt = 33;
*siz = 55;
*pdt = 150;
CU_ASSERT(*b == true);
CU_ASSERT(*s == 2);
CU_ASSERT(*c == 'a');
CU_ASSERT(*uc == 'b');
CU_ASSERT(*n == 5);
CU_ASSERT(*un == 255);
CU_ASSERT(*l == 550);
CU_ASSERT(*ul == 333);
CU_ASSERT(*ll == 950);
CU_ASSERT(*ull == 111);
CU_ASSERT(*f == 113.5);
CU_ASSERT(*d == 50.8);
CU_ASSERT(*ld == 115.3);
CU_ASSERT(*t == 123);
CU_ASSERT(*ot == 22);
CU_ASSERT(*ipt == 33);
CU_ASSERT(*siz == 55);
CU_ASSERT(*pdt == 150);
CU_ASSERT(IS_ALIGNED(b));
CU_ASSERT(IS_ALIGNED(s));
CU_ASSERT(IS_ALIGNED(c));
CU_ASSERT(IS_ALIGNED(uc));
CU_ASSERT(IS_ALIGNED(n));
CU_ASSERT(IS_ALIGNED(un));
CU_ASSERT(IS_ALIGNED(l));
CU_ASSERT(IS_ALIGNED(ul));
CU_ASSERT(IS_ALIGNED(ll));
CU_ASSERT(IS_ALIGNED(ull));
CU_ASSERT(IS_ALIGNED(f));
CU_ASSERT(IS_ALIGNED(d));
CU_ASSERT(IS_ALIGNED(ld));
CU_ASSERT(IS_ALIGNED(t));
CU_ASSERT(IS_ALIGNED(ot));
CU_ASSERT(IS_ALIGNED(ipt));
CU_ASSERT(IS_ALIGNED(siz));
CU_ASSERT(IS_ALIGNED(pdt));
mpool_destroy(pool);
}
int main (int argc, char *argv[])
{
pthread_t th[NA_ENV_MAX];
na_env_t *env[NA_ENV_MAX];
mpool_t *env_pool;
int c;
int env_cnt = 0;
bool is_daemon = false;
struct json_object *conf_obj = NULL;
struct json_object *environments_obj = NULL;
while (-1 != (c = getopt(argc, argv,
"f:" /* configuration file with JSON */
"t:" /* check configuration file */
"d" /* go to background */
"v" /* show version and information */
"h" /* show help */
)))
{
switch (c) {
case 'd':
is_daemon = true;
break;
case 'f':
ConfFile = optarg;
conf_obj = na_get_conf(optarg);
environments_obj = na_get_environments(conf_obj, &env_cnt);
break;
case 't':
conf_obj = na_get_conf(optarg);
environments_obj = na_get_environments(conf_obj, &env_cnt);
printf("JSON configuration is OK\n");
return 0;
break;
case 'v':
na_version();
return 0;
break;
case 'h':
na_usage();
return 0;
break;
default:
break;
}
}
if (is_daemon && daemon(0, 0) == -1) {
NA_DIE_WITH_ERROR(NA_ERROR_FAILED_DAEMONIZE);
}
if (env_cnt > NA_ENV_MAX) {
NA_DIE_WITH_ERROR(NA_ERROR_TOO_MANY_ENVIRONMENTS);
}
StartTimestamp = time(NULL);
na_setup_signals();
na_memproto_bm_skip_init();
env_pool = mpool_create(0);
if (env_cnt == 0) {
env_cnt = 1;
env[0] = na_env_add(&env_pool);
na_env_setup_default(env[0], 0);
} else {
for (int i=0;i<env_cnt;++i) {
env[i] = na_env_add(&env_pool);
na_env_setup_default(env[i], i);
na_conf_env_init(environments_obj, env[i], i, false);
}
}
json_object_put(conf_obj);
for (int i=0;i<env_cnt;++i) {
env[i]->current_conn = 0;
env[i]->is_refused_active = false;
env[i]->is_refused_accept = false;
env[i]->is_worker_busy = calloc(sizeof(bool), env[i]->worker_max);
for (int j=0;j<env[i]->worker_max;++j) {
env[i]->is_worker_busy[j] = false;
}
env[i]->error_count = 0;
env[i]->current_conn_max = 0;
pthread_mutex_init(&env[i]->lock_connpool, NULL);
pthread_mutex_init(&env[i]->lock_current_conn, NULL);
pthread_mutex_init(&env[i]->lock_tid, NULL);
pthread_mutex_init(&env[i]->lock_loop, NULL);
pthread_mutex_init(&env[i]->lock_error_count, NULL);
pthread_rwlock_init(&env[i]->lock_refused, NULL);
pthread_rwlock_init(&env[i]->lock_request_bufsize_max, NULL);
pthread_rwlock_init(&env[i]->lock_response_bufsize_max, NULL);
pthread_rwlock_init(&LockReconf, NULL);
env[i]->lock_worker_busy = calloc(sizeof(pthread_rwlock_t), env[i]->worker_max);
for (int j=0;j<env[i]->worker_max;++j) {
pthread_rwlock_init(&env[i]->lock_worker_busy[j], NULL);
}
na_connpool_create(&env[i]->connpool_active, env[i]->connpool_max);
if (env[i]->is_use_backup) {
na_connpool_create(&env[i]->connpool_backup, env[i]->connpool_max);
}
}
for (int i=0;i<env_cnt;++i) {
pthread_create(&th[i], NULL, na_event_loop, env[i]);
}
// monitoring signal
while (true) {
if (SigExit == 1) {
break;
}
if (SigReconf == 1) {
conf_obj = na_get_conf(ConfFile);
environments_obj = na_get_environments(conf_obj, &env_cnt);
pthread_rwlock_wrlock(&LockReconf);
for (int i=0;i<env_cnt;++i) {
na_conf_env_init(environments_obj, env[i], i, true);
}
pthread_rwlock_unlock(&LockReconf);
json_object_put(conf_obj);
SigReconf = 0;
}
// XXX we should sleep forever and only wake upon a signal
sleep(1);
}
for (int i=0;i<env_cnt;++i) {
na_connpool_destroy(&env[i]->connpool_active);
if (env[i]->is_use_backup) {
na_connpool_destroy(&env[i]->connpool_backup);
}
pthread_mutex_destroy(&env[i]->lock_connpool);
pthread_mutex_destroy(&env[i]->lock_current_conn);
pthread_mutex_destroy(&env[i]->lock_tid);
pthread_mutex_destroy(&env[i]->lock_error_count);
pthread_rwlock_destroy(&env[i]->lock_refused);
pthread_rwlock_destroy(&env[i]->lock_request_bufsize_max);
pthread_rwlock_destroy(&env[i]->lock_response_bufsize_max);
pthread_rwlock_destroy(&LockReconf);
for (int j=0;j<env[i]->worker_max;++j) {
pthread_rwlock_destroy(&env[i]->lock_worker_busy[j]);
}
NA_FREE(env[i]->is_worker_busy);
NA_FREE(env[i]->lock_worker_busy);
pthread_detach(th[i]);
}
mpool_destroy(env_pool);
return 0;
}
MotoEnv *
moto_createEnv(int flags,char* filename) {
MotoEnv *env = (MotoEnv *)emalloc(sizeof(MotoEnv));
env->flags = flags;
env->filename = filename;
if (flags & MMAN_LEVEL1_FLAG) {
env->mman_level = 1;
}
else if (flags & MMAN_LEVEL2_FLAG) {
env->mman_level = 2;
}
else {
env->mman_level = 0;
}
env->mpool = mpool_create(2048);
env->valpool = opool_createWithExt(
(void*(*)())moto_createEmptyVal,
NULL,
NULL,
NULL,
env,
10
);
env->bufpool = opool_create(
(void*(*)())buf_createDefault,
(void(*)(void*))buf_free,
(void(*)(void*))buf_clear,
NULL,
10
);
env->stkpool = opool_create(
(void*(*)())stack_createDefault,
(void(*)(void*))stack_free,
NULL,
NULL,
10
);
env->fcache = stab_createDefault();
env->tree = moto_createTree();
env->ptrs = hset_createDefault();
env->out = buf_create(DEFAULT_BUF_SIZE);
env->err = buf_create(DEFAULT_BUF_SIZE);
env->types = stab_createDefault();
env->cdefs = stab_createDefault();
env->ccdef = NULL;
env->globals = stab_createDefault();
env->frames = vec_createDefault();
env->ftable = ftab_create();
env->scope = stack_createDefault();
env->rxcache = stab_createDefault();
env->uses = sset_createDefault();
mttab_addBuiltInType(env, "boolean");
mttab_addBuiltInType(env, "byte");
mttab_addBuiltInType(env, "char");
mttab_addBuiltInType(env, "int");
mttab_addBuiltInType(env, "long");
mttab_addBuiltInType(env, "float");
mttab_addBuiltInType(env, "double");
mttab_addBuiltInType(env, "void"); /* Special symbol for the void type */
mttab_addBuiltInType(env, "null"); /* Special symbol for null type */
mttab_addBuiltInType(env, "Object");
mttab_addBuiltInType(env, "String");
mttab_addBuiltInType(env, "Exception");
mttab_addBuiltInType(env, "Regex");
/* compiler extras */
env->includes = sset_createDefault();
sset_add(env->includes, "<stdio.h>");
sset_add(env->includes, "\"mxarr.h\"");
sset_add(env->includes, "\"stringbuffer.h\"");
sset_add(env->includes, "\"excpfn.h\"");
sset_add(env->includes, "\"mman.h\"");
sset_add(env->includes, "\"runtime.h\"");
sset_add(env->includes, "\"cdx_function.h\"");
env->fdefs = htab_createDefault();
env->adefs = htab_createDefault();
env->constantPool = buf_createDefault();
env->constantCount = 0;
env->fcodebuffer = buf_createDefault();
env->curScopeID = 0;
env->scopeIDStack = istack_createDefault();
env->frameindex = -1;
/* error stuff */
env->errs = sset_createDefault();
env->meta.filename = env->filename;
env->meta.caller = NULL;
env->meta.macroname = NULL;
env->meta.lineno = 1;
env->errflag = 0;
return env;
}
