void assembler_run(const char *out_file)
{
compiler_descriptor_t c_descr;
memset(&c_descr, 0, sizeof(compiler_descriptor_t));
FILE *of = fopen(out_file, "wb");
if (of == NULL) {
printf("compiler error: error on opening output file ...\n");
return;
}
token_list_t *list = tokenizer_run(ASM_DESCR.MAIN_FILE);
if (parser_run(list, &c_descr) == 1) {
printf("compiler error: can't compile (parser error) ...\n");
return;
}
int compile_size = -1;
if ((compile_size = fmt_compile(of, &c_descr, list)) != -1) {
if (ferror(of) || fclose(of) == EOF) {
printf("compiler error: error on closing output-file ...\n");
return;
}
printf("compiler success: written buffer into output-file ...\n");
printf("-----------------------------------------------------\n");
printf("output format: %s\n", ASM_DESCR.format);
printf("output length: %u byte/s\n", compile_size);
}
}
// Main entry to the interpret. No tests will be launched, only
// pure interpret will be compiled
int main(int argc, char *argv[]) {
int result;
if ((result = check_params(argc, argv))) {
return result;
}
// naalokujeme sdilenou datovou strukturu
make_data_structure();
// otevrem soubor
set_input(argv[1]);
#ifdef LEX_TEST
do {
get_token();
} while (d->token->type != EOF);
#else
// parse
parser_prepare(d);
d = parser_run();
if (d->error != CODE_OK) {
return 2;
}
InterpretInit(d->tree->d.list);
// interpret the list
InterpretRun();
#endif
return 0;
}
int main(int argc, char *argv[]) {
parser_create();
if (atexit(exit_hook) != 0) {
fprintf(stderr, "could not register exit hook\n");
exit(EXIT_FAILURE);
}
int ret = parser_run();
if (ret == 0) {
puts("{* input looks ok *}");
puts("{* symbol table:");
print_symbol_table();
puts("*}");
print_ast_as_prascal(parser_get_root_node());
}
return ret;
}
int main(int argc, char **argv)
{
int error;
app_subsys **ss;
int exit_signals[2] = {SIGTERM, SIGINT};
struct event terminators[2];
struct event dumper;
bool conftest = false;
int opt;
int i;
red_srand();
while ((opt = getopt(argc, argv, "h?vtc:p:")) != -1) {
switch (opt) {
case 't':
conftest = true;
break;
case 'c':
confname = optarg;
break;
case 'p':
pidfile = optarg;
break;
case 'v':
puts(redsocks_version);
return EXIT_SUCCESS;
default:
printf(
"Usage: %s [-?hvt] [-c config] [-p pidfile]\n"
" -h, -? this message\n"
" -v print version\n"
" -t test config syntax\n"
" -p write pid to pidfile\n",
argv[0]);
return (opt == '?' || opt == 'h') ? EXIT_SUCCESS : EXIT_FAILURE;
}
}
FILE *f = fopen(confname, "r");
if (!f) {
perror("Unable to open config file");
return EXIT_FAILURE;
}
parser_context* parser = parser_start(f, NULL);
if (!parser) {
perror("Not enough memory for parser");
return EXIT_FAILURE;
}
FOREACH(ss, subsystems)
if ((*ss)->conf_section)
parser_add_section(parser, (*ss)->conf_section);
error = parser_run(parser);
parser_stop(parser);
fclose(f);
if (error)
return EXIT_FAILURE;
if (conftest)
return EXIT_SUCCESS;
// Initialize global event base
g_event_base = event_base_new();
if (!g_event_base)
return EXIT_FAILURE;
memset(&dumper, 0, sizeof(dumper));
memset(terminators, 0, sizeof(terminators));
FOREACH(ss, subsystems) {
if ((*ss)->init) {
error = (*ss)->init();
if (error)
goto shutdown;
}
}
if (pidfile) {
f = fopen(pidfile, "w");
if (!f) {
perror("Unable to open pidfile for write");
return EXIT_FAILURE;
}
fprintf(f, "%d\n", getpid());
fclose(f);
}
assert(SIZEOF_ARRAY(exit_signals) == SIZEOF_ARRAY(terminators));
for (i = 0; i < SIZEOF_ARRAY(exit_signals); i++) {
evsignal_assign(&terminators[i], get_event_base(), exit_signals[i], terminate, NULL);
if (evsignal_add(&terminators[i], NULL) != 0) {
log_errno(LOG_ERR, "signal_add");
goto shutdown;
}
}
evsignal_assign(&dumper, get_event_base(), SIGUSR1, dump_handler, NULL);
if (evsignal_add(&dumper, NULL) != 0) {
log_errno(LOG_ERR, "evsignal_add");
goto shutdown;
}
log_error(LOG_NOTICE, "redsocks started");
event_base_dispatch(g_event_base);
log_error(LOG_NOTICE, "redsocks goes down");
shutdown:
if (evsignal_initialized(&dumper)) {
if (evsignal_del(&dumper) != 0)
log_errno(LOG_WARNING, "signal_del");
memset(&dumper, 0, sizeof(dumper));
}
for (i = 0; i < SIZEOF_ARRAY(exit_signals); i++) {
if (evsignal_initialized(&terminators[i])) {
if (evsignal_del(&terminators[i]) != 0)
log_errno(LOG_WARNING, "signal_del");
memset(&terminators[i], 0, sizeof(terminators[i]));
}
}
for (--ss; ss >= subsystems; ss--)
if ((*ss)->fini)
(*ss)->fini();
if (g_event_base)
event_base_free(g_event_base);
return !error ? EXIT_SUCCESS : EXIT_FAILURE;
}
/* Top level wrapper around the parser */
int ini_config_parse(struct ini_cfgfile *file_ctx,
int error_level,
uint32_t collision_flags,
uint32_t parse_flags,
struct ini_cfgobj *ini_config)
{
int error = EOK;
struct parser_obj *po = NULL;
uint32_t fl1, fl2, fl3;
TRACE_FLOW_ENTRY();
if ((!ini_config) || (!(ini_config->cfg))) {
TRACE_ERROR_NUMBER("Invalid argument", EINVAL);
return EINVAL;
}
if (!file_ctx) {
TRACE_ERROR_NUMBER("Invalid file context", EINVAL);
return EINVAL;
}
if (!valid_collision_flags(collision_flags)) {
TRACE_ERROR_NUMBER("Invalid flags.", EINVAL);
return EINVAL;
}
if ((error_level != INI_STOP_ON_ANY) &&
(error_level != INI_STOP_ON_NONE) &&
(error_level != INI_STOP_ON_ERROR)) {
TRACE_ERROR_NUMBER("Invalid argument", EINVAL);
return EINVAL;
}
error = parser_create(ini_config,
file_ctx->file,
file_ctx->filename,
error_level,
collision_flags,
parse_flags,
&po);
if (error) {
TRACE_ERROR_NUMBER("Failed to perform an action", error);
return error;
}
error = parser_run(po);
if (error) {
fl1 = collision_flags & INI_MS_MASK;
fl2 = collision_flags & INI_MV1S_MASK;
fl3 = collision_flags & INI_MV2S_MASK;
if ((error == EEXIST) &&
(((fl1 == INI_MS_DETECT) &&
(fl2 != INI_MV1S_ERROR) &&
(fl3 != INI_MV2S_ERROR)) ||
((fl2 == INI_MV1S_DETECT) &&
(fl1 != INI_MS_ERROR) &&
(fl3 != INI_MV2S_ERROR)) ||
((fl3 == INI_MV2S_DETECT) &&
(fl1 != INI_MS_ERROR) &&
(fl2 != INI_MV1S_ERROR)))) {
TRACE_ERROR_NUMBER("No error in detect mode", error);
/* Fall through */
}
else {
TRACE_ERROR_NUMBER("Failed to parse file", error);
TRACE_ERROR_NUMBER("Mode", collision_flags);
col_get_collection_count(ini_config->error_list, &(ini_config->count));
if(ini_config->count) (ini_config->count)--;
parser_destroy(po);
return error;
}
}
/* If should be empty anyways */
col_destroy_collection_with_cb(ini_config->cfg, ini_cleanup_cb, NULL);
ini_config->cfg = po->top;
po->top = NULL;
parser_destroy(po);
TRACE_FLOW_EXIT();
return error;
}
int main(int argc, char **argv)
{
int error;
app_subsys **ss;
int exit_signals[2] = {SIGTERM, SIGINT};
struct event terminators[2];
bool conftest = false;
int opt;
int i;
evutil_secure_rng_init();
while ((opt = getopt(argc, argv, "h?vtc:p:")) != -1) {
switch (opt) {
case 't':
conftest = true;
break;
case 'c':
confname = optarg;
break;
case 'p':
pidfile = optarg;
break;
case 'v':
puts(redsocks_version);
printf("Built with libevent-%s\n", LIBEVENT_VERSION);
printf("Runs with libevent-%s\n", event_get_version());
if (LIBEVENT_VERSION_NUMBER != event_get_version_number()) {
printf("Warning: libevent version number mismatch.\n"
" Headers: %8x\n"
" Runtime: %8x\n", LIBEVENT_VERSION_NUMBER, event_get_version_number());
}
return EXIT_SUCCESS;
default:
printf(
"Usage: %s [-?hvt] [-c config] [-p pidfile]\n"
" -h, -? this message\n"
" -v print version\n"
" -t test config syntax\n"
" -p write pid to pidfile\n",
argv[0]);
return (opt == '?' || opt == 'h') ? EXIT_SUCCESS : EXIT_FAILURE;
}
}
if (event_get_struct_event_size() != sizeof(struct event)) {
puts("libevent event_get_struct_event_size() != sizeof(struct event)! Check `redsocks -v` and recompile redsocks");
return EXIT_FAILURE;
}
FILE *f = fopen(confname, "r");
if (!f) {
perror("Unable to open config file");
return EXIT_FAILURE;
}
parser_context* parser = parser_start(f);
if (!parser) {
perror("Not enough memory for parser");
return EXIT_FAILURE;
}
FOREACH(ss, subsystems)
if ((*ss)->conf_section)
parser_add_section(parser, (*ss)->conf_section);
error = parser_run(parser);
parser_stop(parser);
fclose(f);
if (error)
return EXIT_FAILURE;
if (conftest)
return EXIT_SUCCESS;
struct event_base* evbase = event_init();
memset(terminators, 0, sizeof(terminators));
FOREACH(ss, subsystems) {
if ((*ss)->init) {
error = (*ss)->init(evbase);
if (error)
goto shutdown;
}
}
if (pidfile) {
f = fopen(pidfile, "w");
if (!f) {
perror("Unable to open pidfile for write");
return EXIT_FAILURE;
}
fprintf(f, "%d\n", getpid());
fclose(f);
}
assert(SIZEOF_ARRAY(exit_signals) == SIZEOF_ARRAY(terminators));
for (i = 0; i < SIZEOF_ARRAY(exit_signals); i++) {
signal_set(&terminators[i], exit_signals[i], terminate, NULL);
if (signal_add(&terminators[i], NULL) != 0) {
log_errno(LOG_ERR, "signal_add");
goto shutdown;
}
}
if (LIBEVENT_VERSION_NUMBER != event_get_version_number()) {
log_error(LOG_WARNING, "libevent version mismatch! headers %8x, runtime %8x\n", LIBEVENT_VERSION_NUMBER, event_get_version_number());
}
log_error(LOG_NOTICE, "redsocks started, conn_max=%u", redsocks_conn_max());
event_dispatch();
log_error(LOG_NOTICE, "redsocks goes down");
shutdown:
for (i = 0; i < SIZEOF_ARRAY(exit_signals); i++) {
if (signal_initialized(&terminators[i])) {
if (signal_del(&terminators[i]) != 0)
log_errno(LOG_WARNING, "signal_del");
memset(&terminators[i], 0, sizeof(terminators[i]));
}
}
for (--ss; ss >= subsystems; ss--)
if ((*ss)->fini)
(*ss)->fini();
event_base_free(evbase);
return !error ? EXIT_SUCCESS : EXIT_FAILURE;
}
