static void
init(void) {
#ifdef ANDROID
logger_init(0);
#else
logger_init(daemon_mode);
#endif
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
#if !defined(_WIN32)
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGABRT, SIG_IGN);
#endif
if (crypto_init(password)) {
logger_stderr("crypto init failed");
exit(1);
}
if (idle_timeout == 0) {
idle_timeout = 60;
}
#if !defined(_WIN32)
if (acl_file != NULL) {
acl = !acl_init(acl_file);
}
#endif
}
int edp_init(int thread_num){
int ret = -1;
ret = logger_init();
if(ret != 0){
return ret;
}
// FIXME:pre-alloc memory for your application
ret = mcache_init(NULL, 0);
if(ret != 0){
log_warn("mcache init fail:%d\n", ret);
goto exit_mcache;
}
ret = hset_init();
if(ret != 0){
log_warn("hset init fail:%d\n", ret);
goto exit_hset;
}
ret = worker_init(thread_num);
if(ret != 0){
log_warn("init worker fail:%d\n", ret);
goto exit_worker;
}
ret = emit_init();
if(ret != 0){
log_warn("init emitter fail:%d\n", ret);
goto exit_emit;
}
ret = edpnet_init();
if(ret != 0){
log_warn("init edpnet fail:%d\n", ret);
goto exit_net;
}
log_info("edp have been initialized!\n");
return 0;
exit_net:
emit_fini();
exit_emit:
worker_fini();
exit_worker:
hset_fini();
exit_hset:
mcache_fini();
exit_mcache:
logger_fini();
return ret;
}
void logger_log(logger_level l, char *loc, char *format, ...)
{
va_list args;
if (l < level) {
return;
}
if (!fp) {
if (logger_init() != 0) {
return;
}
}
va_start(args, format);
fprintf(fp, "%s - ", loc);
vfprintf(fp, format, args);
fprintf(fp, "\n");
va_end(args);
fflush(fp);
}
int main(int argc, char **argv) {
rtmp_state_t st;
int to_write;
if (argc != 3) {
fprintf(stderr, "usage: %s <url> <0|1>\n", argv[0]);
return 1;
}
logger_init("/dev/stderr");
//set_logger_level(LOG_DEBUG);
set_logger_level(LOG_INFO);
to_write = atoi(argv[2]) ? 1 : 0;
st.remote_url = argv[1];
st.flv_path = "dump.flv";
if (rtmp_state_init(&st, to_write)) {
my_log_error("rtmp_state_init() failed");
return 1;
}
if (rtmp_handshake(&st)) {
my_log_error("handshake is unsuccessful");
return 1;
}
my_log_info("handshake is successful");
if (rtmp_send_connect(&st)) {
my_log_error("connect failed");
return 1;
}
if (to_write) {
if (rtmp_client_wait_publishing(&st))
return 1;
my_log_info("ready to send media");
if (rtmp_send_media(&st)) {
my_log_info("error sending media");
return 1;
}
} else {
if (rtmp_client_wait_play(&st))
return 1;
my_log_info("ready to play");
if (rtmp_receive_media(&st)) {
my_log_info("error getting media");
return 1;
}
}
rtmp_state_free(&st);
return 0;
}
int main()
{
GUI* gui=NULL;
LOGGER* log=NULL;
CONFIG* con=NULL;
log=logger_init("logs/test.log");
logger_log(log,"Creating Config Reader");
con=config_init();
logger_log(log,"Config reader ready");
logger_log(log,"No config files to load");
logger_log(log,"Building GUI");
gui=build_gui();
logger_log(log,"GUI built");
logger_log(log,"Entering Main loop");
while(is_open(gui)){
usleep(100);
//This is where data collection can take place
}
logger_log(log,"Exiting main Loop");
logger_log(log,"Shutting down GUI");
clean_up_gui(gui);
logger_log(log,"Cleaning up the config reader");
config_destroy(con);
logger_log(log,"Shutting down Logger");
logger_shutdown(log);
}
int main(int argc, char *argv[])
{
me.ev = mowgli_eventloop_create();
signals_init();
parse_commandline_options(argc, argv);
me.config = mowgli_config_file_load(config_file);
if(me.config == NULL)
sigyn_fatal("Cannot load configuration file.");
logger_init(me.config->entries);
config_check(me.config);
me.uplink.line = new_conn(me.uplink.hostname, me.uplink.port, me.uplink.ssl, read_irc, NULL);
if (me.uplink.line == NULL)
sigyn_fatal("Connection to uplink failed.");
me.uplink.connected = true;
loadmodules(me.config->entries);
sigyn_introduce_client(me.client->nick, me.client->user, NULL);
if (should_fork)
daemonise(SYSCONFDIR "/sigyn.pid");
mowgli_eventloop_run(me.ev);
sigyn_cleanup();
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
int i;
/* Initialize the logger module. */
logger_init(LOG_LEVEL_DEBUG);
/* Log to stderr. */
logger_add_fp_handler(stderr);
/* Add a callback handler. */
logger_add_callback_handler(log_callback, NULL);
/* Add a rotating file handler. */
logger_add_rotating_handler("demo_log", 5000, 3);
/* Log an info message. */
for (i = 0; i < 5; i++) {
log_info("Info log %d", i);
log_debug("Debug log %d", i);
}
/* Reset the logger - frees all allocated resources and keeps
* valgrind happy. */
logger_reset();
return 0;
}
int main( int argc, char **argv )
{
char *cfg_file;
char *module_name;
module_t *module;
__get_args( &cfg_file, &module_name, argc, argv );
main_init();
module = module_get( module_name );
config_init( cfg_file, module->cfg_init_cb );
logger_init();
net_init();
http_init();
module->init_cb();
net_main_loop();
return 0;
}
static void
init(void) {
logger_init(daemon_mode);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
#ifndef _WIN32
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGABRT, SIG_IGN);
#endif
if (crypto_init(password)) {
logger_log(LOG_ERR, "crypto init failed");
exit(1);
}
resolver_prepare(nameserver_num);
uv_key_create(&thread_resolver_key);
if (idle_timeout == 0) {
idle_timeout = 60;
}
}
static void frontend_gx_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
#ifndef IS_SALAMANDER
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
g_extern.log_file = fopen("/retroarch-log.txt", "w");
#endif
#endif
#ifdef HW_DOL
chdir("carda:/retroarch");
#endif
getcwd(g_defaults.core_dir, MAXPATHLEN);
char *last_slash = strrchr(g_defaults.core_dir, '/');
if (last_slash)
*last_slash = 0;
char *device_end = strchr(g_defaults.core_dir, '/');
if (device_end)
snprintf(g_defaults.port_dir, sizeof(g_defaults.port_dir), "%.*s/retroarch", device_end - g_defaults.core_dir, g_defaults.core_dir);
else
fill_pathname_join(g_defaults.port_dir, g_defaults.port_dir, "retroarch", sizeof(g_defaults.port_dir));
fill_pathname_join(g_defaults.overlay_dir, g_defaults.core_dir, "overlays", sizeof(g_defaults.overlay_dir));
fill_pathname_join(g_defaults.config_path, g_defaults.port_dir, "retroarch.cfg", sizeof(g_defaults.config_path));
fill_pathname_join(g_defaults.system_dir, g_defaults.port_dir, "system", sizeof(g_defaults.system_dir));
fill_pathname_join(g_defaults.sram_dir, g_defaults.port_dir, "savefiles", sizeof(g_defaults.sram_dir));
fill_pathname_join(g_defaults.savestate_dir, g_defaults.port_dir, "savefiles", sizeof(g_defaults.savestate_dir));
#ifdef IS_SALAMANDER
if (*argc > 2 && argv[1] != NULL && argv[2] != NULL)
fill_pathname_join(gx_rom_path, argv[1], argv[2], sizeof(gx_rom_path));
else
gx_rom_path[0] = '\0';
#else
#ifdef HW_RVL
// needed on Wii; loaders follow a dumb standard where the path and filename are separate in the argument list
if (*argc > 2 && argv[1] != NULL && argv[2] != NULL)
{
static char path[PATH_MAX];
*path = '\0';
struct rarch_main_wrap *args = (struct rarch_main_wrap*)params_data;
if (args)
{
fill_pathname_join(path, argv[1], argv[2], sizeof(path));
args->touched = true;
args->no_rom = false;
args->verbose = false;
args->config_path = NULL;
args->sram_path = NULL;
args->state_path = NULL;
args->rom_path = path;
args->libretro_path = NULL;
}
}
#endif
#endif
}
static void get_environment_settings(int argc, char *argv[])
{
#ifndef IS_SALAMANDER
g_extern.verbose = true;
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
g_extern.log_file = fopen("ms0:/retroarch-log.txt", "w");
#endif
#endif
fill_pathname_basedir(default_paths.port_dir, argv[0], sizeof(default_paths.port_dir));
RARCH_LOG("port dir: [%s]\n", default_paths.port_dir);
snprintf(default_paths.core_dir, sizeof(default_paths.core_dir), "%s/cores", default_paths.port_dir);
snprintf(default_paths.savestate_dir, sizeof(default_paths.savestate_dir), "%s/savestates", default_paths.core_dir);
snprintf(default_paths.filesystem_root_dir, sizeof(default_paths.filesystem_root_dir), "/");
snprintf(default_paths.filebrowser_startup_dir, sizeof(default_paths.filebrowser_startup_dir), default_paths.filesystem_root_dir);
snprintf(default_paths.sram_dir, sizeof(default_paths.sram_dir), "%s/savefiles", default_paths.core_dir);
snprintf(default_paths.system_dir, sizeof(default_paths.system_dir), "%s/system", default_paths.core_dir);
/* now we fill in all the variables */
snprintf(default_paths.menu_border_file, sizeof(default_paths.menu_border_file), "%s/borders/Menu/main-menu.png", default_paths.core_dir);
snprintf(default_paths.border_dir, sizeof(default_paths.border_dir), "%s/borders", default_paths.core_dir);
snprintf(g_extern.config_path, sizeof(g_extern.config_path), "%s/retroarch.cfg", default_paths.port_dir);
}
mf_handle_t mf_open(const char *pathname) {
created_logger = logger_init("log.txt");
if(pathname == NULL) {
errno = EINVAL;
write_log_to_file(Error,"mf_open: wrong pathname, its value is NULL!\n");
return NULL;
}
int fd = open(pathname, O_RDWR, 0666);
if(fd == -1) {
write_log_to_file(Error,"mf_open: problems with file, fd = -1!\n");
return NULL;
}
ch_pool_t *ch_pool;
ch_pool = ch_pool_init(fd, PROT_READ | PROT_WRITE);
ch_pool -> flag = 0;
if(ch_pool == NULL) {
write_log_to_file(Error,"mf_open: chunk pool initialization failed!\n");
return NULL;
}
ch_pool -> file_size = mf_file_size((mf_handle_t)ch_pool);
ch_pool -> chunk_size_min = get_chunk_size(1);
if(strcmp(pathname, "test0") == 0) {
ch_pool -> flag = 1;
}
return (mf_handle_t)ch_pool;
}
int main(int argc, char **argv)
{
logger_t *lg_test;
lg_test = logger_init();
logger_set_level (lg_test, LOGGER_DEBUG);
logger_set_callback(lg_test, cb, NULL);
logger_log(lg_test, LOGGER_DEBUG, "test %s", "Hello world\n" );
return 0;
}
int logger_config_init(void)
{
char *verbosity_string;
if (config_get_with_default_macro(NULL, CONFIG_LOG_VERBOSITY, &verbosity_string) != 0)
{
error_log("Unable to get log verbosity! This indicates a problem with the config service.");
return -1;
}
int verbosity = lookup_verbosity(verbosity_string);
logLevel = verbosity;
g_free(verbosity_string);
if (verbosity == -1)
{
error_log("Verbosity value is invalid!");
return -1;
}
int log_to_stderr_only;
if ((config_get_int(NULL, CONFIG_FORCE_STDERR_LOGGING, &log_to_stderr_only) == 0) && (log_to_stderr_only != 0))
{
// Report success, even though we haven't done anything
return 0;
}
int timeout;
if (config_get_int_with_default_macro(NULL, CONFIG_LOG_TIMEOUT, &timeout) != 0)
{
error_log("Unable to get log timeout! This indicates a problem with the config service.");
return -1;
}
char *endpoint;
if (config_get_with_default_macro(NULL, CONFIG_LOG_CONNECT_ENDPOINT, &endpoint) != 0)
{
error_log("Could not determine logger endpoint!");
return -1;
}
int ret = logger_init(verbosity, endpoint, timeout);
g_free(endpoint);
if (ret != 0)
{
fprintf(stderr, "Failed to create log transport\n");
return -1;
}
return 0;
}
static void rarch_get_environment(int argc, char *argv[])
{
g_extern.verbose = true;
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
g_extern.log_file = fopen("/retroarch-log.txt", "w");
#endif
if (frontend_ctx && frontend_ctx->environment_get)
frontend_ctx->environment_get(argc, argv);
config_load();
#if defined(RARCH_CONSOLE)
init_libretro_sym(false);
rarch_init_system_info();
global_init_drivers();
#ifdef HAVE_LIBRETRO_MANAGEMENT
char path_prefix[PATH_MAX];
#if defined(_WIN32)
char slash = '\\';
#else
char slash = '/';
#endif
snprintf(path_prefix, sizeof(path_prefix), "%s%c", default_paths.core_dir, slash);
char core_exe_path[256];
snprintf(core_exe_path, sizeof(core_exe_path), "%sCORE%s", path_prefix, DEFAULT_EXE_EXT);
// Save new libretro core path to config file and exit
if (path_file_exists(core_exe_path))
if (libretro_install_core(path_prefix, core_exe_path))
#ifdef _XBOX
g_extern.system.shutdown = g_extern.system.shutdown;
#else
g_extern.system.shutdown = true;
#endif
#endif
#ifdef GEKKO
/* Per-core input config loading */
char core_name[64];
libretro_get_current_core_pathname(core_name, sizeof(core_name));
snprintf(g_extern.input_config_path, sizeof(g_extern.input_config_path), "%s/%s.cfg", default_paths.input_presets_dir, core_name);
config_read_keybinds(g_extern.input_config_path);
#endif
#endif
}
int main() {
event_init();
logger_init(".server_log");
struct acceptor acceptor;
if (initialize_acceptor(&acceptor) == -1) {
return -1;
}
event_dispatch();
free_acceptor(&acceptor);
return 0;
}
static void frontend_psp_get_environment_settings(int *argc, char *argv[],
void *args, void *params_data)
{
(void)args;
#ifndef IS_SALAMANDER
g_extern.verbose = true;
#if defined(HAVE_LOGGER)
logger_init();
#elif defined(HAVE_FILE_LOGGER)
g_extern.log_file = fopen("ms0:/retroarch-log.txt", "w");
#endif
#endif
strlcpy(eboot_path, argv[0], sizeof(eboot_path));
fill_pathname_basedir(g_defaults.port_dir, argv[0], sizeof(g_defaults.port_dir));
RARCH_LOG("port dir: [%s]\n", g_defaults.port_dir);
fill_pathname_join(g_defaults.assets_dir, g_defaults.port_dir, "media", sizeof(g_defaults.assets_dir));
fill_pathname_join(g_defaults.core_dir, g_defaults.port_dir, "cores", sizeof(g_defaults.core_dir));
fill_pathname_join(g_defaults.core_info_dir, g_defaults.port_dir, "cores", sizeof(g_defaults.core_info_dir));
fill_pathname_join(g_defaults.savestate_dir, g_defaults.core_dir, "savestates", sizeof(g_defaults.savestate_dir));
fill_pathname_join(g_defaults.sram_dir, g_defaults.core_dir, "savefiles", sizeof(g_defaults.sram_dir));
fill_pathname_join(g_defaults.system_dir, g_defaults.core_dir, "system", sizeof(g_defaults.system_dir));
fill_pathname_join(g_defaults.config_path, g_defaults.port_dir, "retroarch.cfg", sizeof(g_defaults.config_path));
if (argv[1] && (argv[1][0] != '\0'))
{
static char path[PATH_MAX];
*path = '\0';
struct rarch_main_wrap *args = (struct rarch_main_wrap*)params_data;
if (args)
{
strlcpy(path, argv[1], sizeof(path));
args->touched = true;
args->no_rom = false;
args->verbose = false;
args->config_path = NULL;
args->sram_path = NULL;
args->state_path = NULL;
args->rom_path = path;
args->libretro_path = NULL;
RARCH_LOG("argv[0]: %s\n", argv[0]);
RARCH_LOG("argv[1]: %s\n", argv[1]);
RARCH_LOG("argv[2]: %s\n", argv[2]);
RARCH_LOG("Auto-start game %s.\n", argv[1]);
}
}
}
/* Wrapper functions for logging */
void PSC_initLog(FILE* logfile)
{
PSC_logger = logger_init("PSC", logfile);
if (!PSC_logger) {
if (logfile) {
fprintf(logfile, "%s: failed to initialize logger\n", __func__);
} else {
syslog(LOG_CRIT, "%s: failed to initialize logger", __func__);
}
exit(1);
}
}
int main(int argc, char *argv[])
{
NNTI_result_t rc;
selfsend_args *ssa;
char server_url[NNTI_URL_LEN];
logger_init(LOG_ERROR, NULL);
pthread_barrier_init(&barrier2, NULL, 2);
pthread_barrier_init(&barrier3, NULL, 3);
rc=NNTI_init(NNTI_DEFAULT_TRANSPORT, NULL, &trans_hdl);
rc=NNTI_get_url(&trans_hdl, server_url, NNTI_URL_LEN);
launch_wait_threads();
pthread_barrier_wait(&barrier3);
rc=NNTI_connect(
&trans_hdl,
server_url,
5000,
&server_hdl);
pthread_barrier_wait(&barrier2);
rc=NNTI_alloc(&trans_hdl, NNTI_REQUEST_BUFFER_SIZE, 1, NNTI_SEND_SRC, &send_mr);
ssa=(selfsend_args *)NNTI_BUFFER_C_POINTER(&send_mr);
ssa->data.int_val =10;
ssa->data.float_val =10.0;
ssa->data.double_val=10.0;
ssa->chksum=calc_checksum((const char *)&ssa->data, sizeof(data_t));
rc=NNTI_send(&server_hdl, &send_mr, &recv_mr, &send_wr);
rc=NNTI_wait(&send_wr, 5000, &send_status);
rc=NNTI_send(&server_hdl, &send_mr, NULL, &send_wr);
rc=NNTI_wait(&send_wr, 5000, &send_status);
pthread_barrier_wait(&barrier3);
NNTI_free(&send_mr);
join_wait_threads();
if (success)
std::cout << "\nEnd Result: TEST PASSED" << std::endl;
else
std::cout << "\nEnd Result: TEST FAILED" << std::endl;
return (success ? 0 : 1 );
}
int main() {
const char *config_name = "log";
const char *default_config_path = "config";
logger_init(config_name);
mlog(LOG_INFO, "started");
QuorumPeer peer(default_config_path);
peer.start();
return 0;
}
int main(int argc, char *argv[])
{
int rc;
nssi_service svc;
logger_init(LOG_ERROR, "nssiselfsend.log");
pthread_barrier_init(&barrier, NULL, 2);
// common init
nssi_rpc_init(NSSI_DEFAULT_TRANSPORT, NSSI_DEFAULT_ENCODE, NULL);
launch_wait_thread();
// wait for the service to initialize
pthread_barrier_wait(&barrier);
// client init
nssi_init(NSSI_DEFAULT_TRANSPORT);
for (int i=0; i < 3; i++) {
log_debug(selfsend_debug_level, "Try to connect to server: attempt #%d", i);
rc=nssi_get_service(NSSI_DEFAULT_TRANSPORT, my_url.c_str(), 5000, &svc);
if (rc == NSSI_OK)
break;
else if (rc != NSSI_ETIMEDOUT) {
log_error(selfsend_debug_level, "could not get svc description: %s",
nssi_err_str(rc));
break;
}
}
sleep(1);
// shutdown the service
rc = nssi_kill(&svc, 0, 5000);
// finalize the client
nssi_fini(NSSI_DEFAULT_TRANSPORT);
join_wait_thread();
// finalize the NSSI library
rc = nssi_rpc_fini(NSSI_DEFAULT_TRANSPORT);
if (rc != NSSI_OK)
log_error(selfsend_debug_level, "Error in nssi_rpc_fini");
logger_fini();
return 0;
}
int main(void)
{
int retval = 0;
bool status;
logger_init();
status = remove_log_entries(0, 1, 0, NO_FAILURE_EXPECTED);
print_status("Remove from empty log", status, &retval);
status = add_log_entries(0, 1, NO_FAILURE_EXPECTED);
print_status("Add single entry", status, &retval);
status = remove_log_entries(0, 1, NO_EOF_EXPECTED, NO_MISMATCH_EXPECTED);
print_status("Remove single entry", status, &retval);
status = add_log_entries(0, LOGGER_NUM_ENTRIES - 1, NO_FAILURE_EXPECTED);
print_status("Fill log", status, &retval);
status = add_log_entries(0, 1, 0);
print_status("Overfill log", status, &retval);
status = remove_log_entries(0, LOGGER_NUM_ENTRIES - 1,
NO_EOF_EXPECTED, NO_MISMATCH_EXPECTED);
print_status("Remove all entries", status, &retval);
status = remove_log_entries(0, 1, NO_EOF_EXPECTED, 0);
print_status("Remove fill warning", status, &retval);
status = add_log_entries(0, 16, NO_FAILURE_EXPECTED);
print_status("Add entries 0-15", status, &retval);
status = remove_log_entries(0, 5, NO_EOF_EXPECTED, NO_MISMATCH_EXPECTED);
print_status("Removed entries 0-5", status, &retval);
status = add_log_entries(16, 21, NO_FAILURE_EXPECTED);
print_status("Add 5 more entries: 16-20", status, &retval);
status = remove_log_entries(5, 20, NO_EOF_EXPECTED, NO_MISMATCH_EXPECTED);
print_status("Removed entries 5-19", status, &retval);
status = remove_log_entries(20, 21, NO_EOF_EXPECTED, NO_MISMATCH_EXPECTED);
print_status("Removed entry 20", status, &retval);
status = remove_log_entries(21, 22, 21, NO_MISMATCH_EXPECTED);
print_status("Got expected EOF", status, &retval);
return retval;
}
int main(int argc, char* argv[])
{
state_st state = {0};
// set locale, otherwise we cant use unicode characters for the walls
setlocale(LC_ALL, "");
// seed random #
srand(time(NULL));
// check for logging
if (argc > 1) {
if (!strcmp(argv[1], "--debug")) {
logger_set_level(LOGGER_LEVEL_DEBUG);
} else if (!strcmp(argv[1], "--verbose")) {
logger_set_level(LOGGER_LEVEL_VERBOSE);
} else if (!strcmp(argv[1], "--warn")) {
logger_set_level(LOGGER_LEVEL_WARN);
} else if (!strcmp(argv[1], "--error")) {
logger_set_level(LOGGER_LEVEL_ERROR);
}
}
// set up logger. If no level has been set this call will do nothing.
logger_init();
// set up game state
game_init(&state);
// welcome screen. get rogue's name, roll rogue
welcome(&state);
// game loop
do {
// draw
draw(&state);
// input
input_handler(&state);
} while(state.running);
endwin();
free_state(&state);
logger_stop();
return (EXIT_SUCCESS);
}
int main(
int argc,
char* argv[])
{
int i;
logger_init(1);
logger_set_instant_func(print_message_cli);
if((timer = timer_init()) == NULL)
{
printf("Failed to create timer!\n");
return 1;
}
common_init();
/* We do this first, because the installation
* of the sighandler may cause a segfault
* when ^C is pressed while asking for the language
* we want */
rInit(&game_server_array, cmp_game_server);
rInit(&client_array, NULL);
network_set_loggers(NULL, NULL, logger_message);
signal(SIGINT , &sighandler);
/*
* Let's ask the user if necessary!
*/
read_config(COMMANDLINE);
for(i = 1 ; i < argc ; i++)
{
if(!strcmp(argv[i], "-h"))
help(argv[0]);
else if(!strcmp(argv[i], "-c"))
{
information();
quit();
}
}
thread_create(web_t, register_start_web_interface, NULL);
register_thread_listen(&tcp, (int*)&exit_time);
quit();
return 0;
}
int main(int argc, char *argv[]) {
log_level debug_level=LOG_ALL;
logger_init(LOG_ERROR, NULL);
log_debug(debug_level, "print number=%d", 10);
log_info(debug_level, "print number=%d", 11);
log_warn(debug_level, "warn msg");
log_error(debug_level, "error msg");
log_fatal(debug_level, "fatal msg");
logger_fini();
return 0;
}
int main(int argc, char **argv) {
printf("Starting Simple Http Server...\n");
struct server_parameters server_parameters;
if (parse_arguments(argc, argv, &server_parameters) < 0) {
printf("Failed to parse cmd arguments\n");
goto exit;
}
printf("Server parameters: ");
print_server_parameters(&server_parameters);
printf("\n");
if (daemonize() < 0) {
printf("Failed to become daemon process.\n");
goto exit;
}
if (logger_init(&logger, LOG_FILE) < 0) {
exit(-2);
}
to_log(&logger, "Simple http server with pid %d started logging.\n", getpid());
/* lets remove dead processes */
struct sigaction sa;
sa.sa_handler = sigchld_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
to_log(&logger, "Failed to set up SIGCHLD handler: %d\n",
strerror(errno));
goto exit_with_logging;
}
accept_clients_loop(&server_parameters);
sleep(3);
to_log(&logger, "Simple http server is stopping.\n");
exit_with_logging:
logger_close(&logger);
exit:
return 0;
}
App* appe_create_app_instance(int argc, const char *argv[])
{
App *app = &s_app;
s_argc = argc;
s_argv = argv;
if (s_app_exist) {
return app;
}
app->msg_queue = &s_msg_queue;
app->looper = &s_looper;
app->init = init;
app->register_message_handler = register_message_handler;
app->parse_options = parse_options;
app->save_options = save_options;
app->run = run;
app->quit = quit;
// init zlog system.
/* char log_file_dir[1024];
* memset(log_file_dir, 0, sizeof(log_file_dir));
* getcwd(log_file_dir, sizeof(log_file_dir)); */
logger_init(&s_logger, LOG_FILE, LOG_CONFIG_PATH, LOG_FILE_DIR);
// TaskManager
TaskManager *task_manager = create_taskmanager_instance();
// create tcp server groups instance
AppeTcpServerGroups *tcp_server_groups = appe_create_tcp_server_groups_instance();
tcp_server_groups->init(tcp_server_groups);
// create tcp slave groups instance
AppeTcpSlaveGroups *tcp_slave_groups = appe_create_tcp_slave_groups_instance();
tcp_slave_groups->init(tcp_slave_groups);
// set Servers .etc
app->tcp_server_groups = tcp_server_groups;
app->tcp_slave_groups = tcp_slave_groups;
app->task_manager = task_manager;
app->version = get_version;
app->logger = &s_logger;
s_app_exist = 1;
return app;
}
void
dnscore_init()
{
if(dnscore_init_done)
{
return;
}
dnscore_init_done = TRUE;
dnscore_arch_checkup();
//random_init(time(NULL));
thread_pool_setup_random_ctx();
random_ctx rnd = thread_pool_get_random_ctx();
// random NEEDS to work.
{
u32 r0 = random_next(rnd);
u32 r1 = random_next(rnd);
u32 r2 = random_next(rnd);
u32 r3 = random_next(rnd);
if( ((r0 == 0) && (r1 == 0) && (r2 == 0) && (r3 == 0)) || ((r0 == r1) && (r1 == r2) && (r2 == r3)) )
{
printf("panic: random generation fails. (%08x,%08x,%08x,%08x)\n", r0, r1, r2, r3);
exit(-1);
}
}
rfc_init();
format_class_init();
dnsformat_class_init();
stdstream_init();
logger_init();
dnscore_register_errors();
#if HAS_TSIG_SUPPORT
tsig_register_algorithms();
#endif
atexit(dnscore_finalize);
dnscore_reset_timer();
}
int main(int argc, char *argv[])
{
logger_parameters params;
params.log_level = LOG_LEVEL_NORMAL;
params.log_format = LOG_FORMAT_JSON;
if ( argc > 1)
{
params.log_file_path = argv[1];
params.log_rotate_count = argc > 2 ? atoi(argv[2]) : 0;
logger_init_with_params(¶ms);
}
else
logger_init();
printf("Log level ALL\n");
logger_set_log_level(LOG_LEVEL_ALL);
LOGERROR("some error!");
logger_write("normal",LOG_ENTRY_NORMAL,"the message: %s","normal");
logger_write("err",LOG_ENTRY_ERROR,"the message: %s","error");
logger_write("warn",LOG_ENTRY_WARNING,"the message: %s","warning");
logger_write("info",LOG_ENTRY_INFO,"the message: %s","info");
printf("Log level NORMAL\n");
logger_set_log_level(LOG_LEVEL_NORMAL);
logger_set_use_stdout(1);
logger_write("norm",LOG_ENTRY_NORMAL,"the message: %s","normal");
logger_write("err",LOG_ENTRY_ERROR,"the message: %s","error");
logger_write("warn",LOG_ENTRY_WARNING,"the message: %s","warning");
logger_write("info",LOG_ENTRY_INFO,"the message: %s","info");
printf("Log level ERRORS\n");
logger_set_log_level(LOG_LEVEL_ERRORS);
#ifndef LOGGER_MT
logger_event_start("main",LOG_ENTRY_NORMAL,"logging");
#endif
logger_write("norm",LOG_ENTRY_NORMAL,"the message: %s","normal");
logger_write("err",LOG_ENTRY_ERROR,"the message: %s","error");
logger_write("warn",LOG_ENTRY_WARNING,"the message: %s","warning");
logger_write("info",LOG_ENTRY_INFO,"the message: %s","info");
#ifndef LOGGER_MT
logger_event_end("main",LOG_ENTRY_NORMAL,"logging");
#endif
logger_fini();
return 0;
}
static int
init(void) {
logger_init(daemon_mode);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
signal(SIGABRT, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
if (crypto_init(password)) {
logger_log(LOG_ERR, "crypto init failed");
return 1;
}
return 0;
}
