/*
* The main guy.
*/
int main(int argc, char *argv[])
{
int rcode = EXIT_SUCCESS;
int argval;
const char *input_file = NULL;
const char *output_file = NULL;
const char *filter_file = NULL;
FILE *fp;
REQUEST *request;
VALUE_PAIR *vp;
VALUE_PAIR *filter_vps = NULL;
/*
* If the server was built with debugging enabled always install
* the basic fatal signal handlers.
*/
#ifndef NDEBUG
if (fr_fault_setup(getenv("PANIC_ACTION"), argv[0]) < 0) {
fr_perror("unittest");
exit(EXIT_FAILURE);
}
#endif
if ((progname = strrchr(argv[0], FR_DIR_SEP)) == NULL)
progname = argv[0];
else
progname++;
debug_flag = 0;
set_radius_dir(NULL, RADIUS_DIR);
/*
* Ensure that the configuration is initialized.
*/
memset(&mainconfig, 0, sizeof(mainconfig));
mainconfig.myip.af = AF_UNSPEC;
mainconfig.port = -1;
mainconfig.name = "radiusd";
/*
* The tests should have only IPs, not host names.
*/
fr_hostname_lookups = false;
/*
* We always log to stdout.
*/
fr_log_fp = stdout;
default_log.dst = L_DST_STDOUT;
default_log.fd = STDOUT_FILENO;
/* Process the options. */
while ((argval = getopt(argc, argv, "d:D:f:hi:mMn:o:xX")) != EOF) {
switch(argval) {
case 'd':
set_radius_dir(NULL, optarg);
break;
case 'D':
mainconfig.dictionary_dir = talloc_typed_strdup(NULL, optarg);
break;
case 'f':
filter_file = optarg;
break;
case 'h':
usage(0);
break;
case 'i':
input_file = optarg;
break;
case 'm':
mainconfig.debug_memory = true;
break;
case 'M':
memory_report = true;
mainconfig.debug_memory = true;
break;
case 'n':
mainconfig.name = optarg;
break;
case 'o':
output_file = optarg;
break;
case 'X':
debug_flag += 2;
mainconfig.log_auth = true;
mainconfig.log_auth_badpass = true;
mainconfig.log_auth_goodpass = true;
break;
case 'x':
debug_flag++;
break;
default:
usage(1);
break;
}
}
if (memory_report) {
talloc_enable_null_tracking();
#ifdef WITH_VERIFY_PTR
talloc_set_abort_fn(die_horribly);
#endif
}
talloc_set_log_fn(log_talloc);
if (debug_flag) {
version();
}
fr_debug_flag = debug_flag;
/*
* Mismatch between the binary and the libraries it depends on
*/
if (fr_check_lib_magic(RADIUSD_MAGIC_NUMBER) < 0) {
fr_perror("radiusd");
exit(EXIT_FAILURE);
}
if (rad_check_lib_magic(RADIUSD_MAGIC_NUMBER) < 0) {
exit(EXIT_FAILURE);
}
/* Read the configuration files, BEFORE doing anything else. */
if (mainconfig_init() < 0) {
exit(EXIT_FAILURE);
}
/*
* Load the modules
*/
if (modules_init(mainconfig.config) < 0) {
exit(EXIT_FAILURE);
}
/* Set the panic action (if required) */
if (mainconfig.panic_action &&
#ifndef NDEBUG
!getenv("PANIC_ACTION") &&
#endif
(fr_fault_setup(mainconfig.panic_action, argv[0]) < 0)) {
exit(EXIT_FAILURE);
}
setlinebuf(stdout); /* unbuffered output */
if (!input_file || (strcmp(input_file, "-") == 0)) {
fp = stdin;
} else {
fp = fopen(input_file, "r");
if (!fp) {
fprintf(stderr, "Failed reading %s: %s\n",
input_file, strerror(errno));
exit(EXIT_FAILURE);
}
}
/*
* Grab the VPs from stdin, or from the file.
*/
request = request_setup(fp);
if (!request) {
fprintf(stderr, "Failed reading input: %s\n", fr_strerror());
exit(EXIT_FAILURE);
}
/*
* No filter file, OR there's no more input, OR we're
* reading from a file, and it's different from the
* filter file.
*/
if (!filter_file || filedone ||
((input_file != NULL) && (strcmp(filter_file, input_file) != 0))) {
if (output_file) {
fclose(fp);
fp = NULL;
}
filedone = false;
}
/*
* There is a filter file. If necessary, open it. If we
* already are reading it via "input_file", then we don't
* need to re-open it.
*/
if (filter_file) {
if (!fp) {
fp = fopen(filter_file, "r");
if (!fp) {
fprintf(stderr, "Failed reading %s: %s\n",
filter_file, strerror(errno));
exit(EXIT_FAILURE);
}
}
filter_vps = readvp2(request, fp, &filedone, "radiusd");
if (!filter_vps) {
fprintf(stderr, "Failed reading attributes from %s: %s\n",
filter_file, fr_strerror());
exit(EXIT_FAILURE);
}
/*
* FIXME: loop over input packets.
*/
fclose(fp);
}
rad_virtual_server(request);
if (!output_file || (strcmp(output_file, "-") == 0)) {
fp = stdout;
} else {
fp = fopen(output_file, "w");
if (!fp) {
fprintf(stderr, "Failed writing %s: %s\n",
output_file, strerror(errno));
exit(EXIT_FAILURE);
}
}
print_packet(fp, request->reply);
if (output_file) fclose(fp);
/*
* Update the list with the response type.
*/
vp = radius_paircreate(request->reply, &request->reply->vps,
PW_RESPONSE_PACKET_TYPE, 0);
vp->vp_integer = request->reply->code;
if (filter_vps && !pairvalidate(filter_vps, request->reply->vps)) {
fprintf(stderr, "Output file %s does not match attributes in filter %s\n",
output_file ? output_file : input_file, filter_file);
exit(EXIT_FAILURE);
}
talloc_free(request);
INFO("Exiting normally.");
/*
* Detach any modules.
*/
modules_free();
xlat_free(); /* modules may have xlat's */
/*
* Free the configuration items.
*/
mainconfig_free();
if (memory_report) {
INFO("Allocated memory at time of report:");
log_talloc_report(NULL);
}
return rcode;
}
/**
* @param argc: Number of command line arguments supplied.
* @param argv: Char* array containing the command line arguments supplied.
* @return: To the system, normally 0.
* @brief: The first function once enotes is called.
*/
int
main(int argc, char *argv[])
{
int note_count;
/* IPC Check */
ecore_ipc_init();
dml("IPC Initiated Successfully", 1);
/* loading will increment this if there are notes if not we may need to
* create a blank one */
note_count = 0;
if ((ecore_config_init("enotes")) == ECORE_CONFIG_ERR_FAIL) {
ecore_ipc_shutdown();
return (-1);
}
ecore_app_args_set(argc, (const char **) argv);
ecore_config_app_describe("E-Notes - Sticky Notes for Enlightenment\n\
Copyright (c) Thomas Fletcher\n\
Usage: enotes [options]");
/* Read the Usage and Configurations */
main_config = mainconfig_new();
if (read_configuration(main_config) != ECORE_CONFIG_PARSE_CONTINUE) {
ecore_config_shutdown();
ecore_ipc_shutdown();
ecore_shutdown();
mainconfig_free(main_config);
return (-1);
}
dml("Successfully Read Configurations and Usage", 1);
process_note_storage_locations();
if (find_server() != 0) {
if (remotecmd != NULL)
send_to_server(remotecmd);
else
send_to_server("DEFNOTE");
} else {
dml("Server wasn't found.. Creating one", 1);
/* Setup Server */
setup_server();
/* Initialise the E-Libs */
ecore_init();
ecore_x_init(NULL);
ecore_app_args_set(argc, (const char **) argv);
if (!ecore_evas_init()) {
mainconfig_free(main_config);
return -1;
}
ewl_init(&argc, argv);
edje_init();
dml("Efl Successfully Initiated", 1);
autoload();
/* create autosave timer */
update_autosave();
if (remotecmd != NULL)
handle_ipc_message(remotecmd);
/* Begin the Control Centre */
if (main_config->controlcentre == 1) {
setup_cc();
dml("Control Centre Setup", 1);
} else {
dml("No Control Centre - Displaying Notice", 1);
if (get_note_count() == 0)
new_note();
}
if (main_config->welcome == 1) {
open_welcome();
}
/* Begin the main loop */
dml("Starting Main Loop", 1);
ecore_main_loop_begin();
dml("Main Loop Ended", 1);
/* Save Controlcentre Settings */
set_cc_pos();
autosave();
if (autosave_timer)
ecore_timer_del(autosave_timer);
/* Save and Free the Configuration */
ecore_config_save();
dml("Configuration Saved", 1);
mainconfig_free(main_config);
dml("Configuration Structure Free'd", 1);
/* Shutdown the E-Libs */
edje_shutdown();
ecore_evas_shutdown();
ecore_x_shutdown();
ecore_shutdown();
dml("Efl Shutdown", 1);
}
/* End IPC */
ecore_ipc_shutdown();
dml("IPC Shutdown", 1);
dml("Leaving.", 1);
return (0);
}
