SETUP()
{
view_setup(&lwin);
view_setup(&rwin);
curr_view = &lwin;
other_view = &rwin;
cfg.cd_path = strdup("");
cfg.fuse_home = strdup("");
cfg.slow_fs_list = strdup("");
cfg.use_system_calls = 1;
#ifndef _WIN32
replace_string(&cfg.shell, "/bin/sh");
#else
replace_string(&cfg.shell, "cmd");
#endif
stats_update_shell_type(cfg.shell);
init_commands();
add_builtin_commands(commands, ARRAY_LEN(commands));
called = 0;
undo_setup();
saved_cwd = save_cwd();
}
SETUP()
{
init_commands();
curr_view = &lwin;
other_view = &rwin;
}
/*
Call this function before starting the main loop.
need_to_initialise is 1 if starting a new game or from a gamefile, 0 if loading from a saved game (as saved games contain various initialise stuff)
playing_mission is the index of the mission (MISSION_MISSION1 etc) if playing a mission, 0 otherwise
*/
void init_main_loop(void)
{
// settings.edit_window = EDIT_WINDOW_CLOSED;
// settings.keyboard_capture = INPUT_WORLD;
/*
int i;
for (i = 0; i < MODE_BUTTONS; i ++)
{
inter.mode_button_available [i] = 1;
}
*/
// open_sysmenu();
resize_display_window(settings.option [OPTION_WINDOW_W], settings.option [OPTION_WINDOW_H]);
reset_panel_positions();
// init_ex_control();
init_commands();
clear_sound_list();
//fpr("\n iml: ai %i riai %i", game.area_index, game.region_in_area_index);
if (game.type == GAME_TYPE_MISSION)
reset_music(game.area_index, game.region_in_area_index, rand());
else
reset_music(game.area_index, -1, rand());
flush_game_event_queues();
// game.play_sound = 0;
// game.play_sound_counter = 0;
}
SETUP()
{
conf_setup();
init_modes();
init_commands();
curr_view = &lwin;
other_view = &rwin;
view_setup(&lwin);
curr_stats.load_stage = -1;
curr_stats.save_msg = 0;
saved_cwd = save_cwd();
assert_success(chdir(sandbox));
update_string(&cfg.shell, "/bin/sh");
update_string(&cfg.shell_cmd_flag, "-c");
stats_update_shell_type(cfg.shell);
curr_stats.exec_env_type = EET_EMULATOR;
update_string(&cfg.media_prg, "./script");
create_executable("script");
}
SETUP()
{
lwin.list_rows = 0;
curr_view = &lwin;
init_commands();
add_builtin_commands(commands, ARRAY_LEN(commands));
}
SETUP()
{
curr_view = &lwin;
update_string(&cfg.slow_fs_list, "");
init_commands();
opt_handlers_setup();
view_setup(&lwin);
}
SETUP()
{
view_setup(&lwin);
init_commands();
lwin.sort_g[0] = SK_BY_NAME;
memset(&lwin.sort_g[1], SK_NONE, sizeof(lwin.sort_g) - 1);
opt_handlers_setup();
}
SETUP()
{
curr_view = &lwin;
other_view = &rwin;
init_commands();
cfg.slow_fs_list = strdup("");
init_view(&lwin);
init_view(&rwin);
}
static int server_reconfigure()
{
int i;
if (old_childs_queue) {
ci_debug_printf(1,
"A reconfigure pending. Ignoring reconfigure request.....\n");
return 1;
}
/*shutdown all modules and services and reopen config file */
if (!system_reconfigure())
return 0;
/*initialize commands table for server */
init_commands();
/*
Mark all existing childs as to_be_killed gracefully
(childs_queue.childs[child_indx].to_be_killed = GRACEFULLY)
*/
for (i = 0; i < childs_queue->size; i++) {
if (childs_queue->childs[i].pid != 0) {
childs_queue->childs[i].father_said = GRACEFULLY;
kill(childs_queue->childs[i].pid, SIGTERM);
}
}
/*
Create new shared mem for childs queue
*/
old_childs_queue = childs_queue;
childs_queue = malloc(sizeof(struct childs_queue));
if (!create_childs_queue(childs_queue, 2 * CONF.MAX_SERVERS)) {
ci_debug_printf(1,
"Cannot init shared memory. Fatal error, exiting!\n");
return 0; /*It is not enough. We must wait all childs to exit ..... */
}
/*
Start new childs to handle new requests.
*/
if (CONF.START_SERVERS > CONF.MAX_SERVERS)
CONF.START_SERVERS = CONF.MAX_SERVERS;
for (i = 0; i < CONF.START_SERVERS; i++) {
start_child(LISTEN_SOCKET);
}
/*
When all childs exits release the old shared mem block....
*/
return 1;
}
t_module *get_module(void)
{
if (!(zappy_module = malloc(SIZEMODULE(12))))
return (NULL);
bzero(zappy_module, SIZEMODULE(12));
zappy_module->name = strdup("Zappy Protocol");
zappy_module->delim = strdup("\r\n");
zappy_module->port = -1;
zappy_module->antiflood = 10;
zappy_module->clients = NULL;
init_commands(zappy_module->functions);
return (zappy_module);
}
SETUP()
{
curr_view = &lwin;
other_view = &rwin;
init_commands();
cfg.slow_fs_list = strdup("");
cfg.apropos_prg = strdup("");
cfg.cd_path = strdup("");
cfg.find_prg = strdup("");
cfg.fuse_home = strdup("");
cfg.time_format = strdup("+");
cfg.vi_command = strdup("");
cfg.vi_x_command = strdup("");
cfg.ruler_format = strdup("");
cfg.status_line = strdup("");
cfg.grep_prg = strdup("");
cfg.locate_prg = strdup("");
cfg.border_filler = strdup("");
cfg.shell = strdup("");
lwin.dir_entry = NULL;
lwin.list_rows = 0;
lwin.window_rows = 1;
lwin.sort[0] = SK_NONE;
ui_view_sort_list_ensure_well_formed(&lwin, lwin.sort);
lwin.columns = columns_create();
lwin.view_columns = strdup("");
lwin.num_width_g = 4;
lwin.num_width = 4;
lwin.ls_view = 0;
rwin.dir_entry = NULL;
rwin.list_rows = 0;
rwin.window_rows = 1;
rwin.sort[0] = SK_NONE;
ui_view_sort_list_ensure_well_formed(&rwin, rwin.sort);
rwin.columns = columns_create();
rwin.view_columns = strdup("");
rwin.num_width_g = 4;
rwin.num_width = 4;
rwin.ls_view = 0;
/* Name+size matches default column view setting ("-{name},{}"). */
columns_add_column_desc(SK_BY_NAME, &format_none);
columns_add_column_desc(SK_BY_SIZE, &format_none);
columns_set_line_print_func(&print_func);
init_option_handlers();
}
SETUP()
{
assert_success(chdir(SANDBOX_PATH));
curr_view = &lwin;
other_view = &rwin;
init_commands();
cfg.slow_fs_list = strdup("");
cfg.chase_links = 1;
init_view(&lwin);
init_view(&rwin);
}
SETUP()
{
view_setup(&lwin);
view_setup(&rwin);
/* Emulate proper history initialization (must happen after view
* initialization). */
cfg_resize_histories(5);
cfg_resize_histories(0);
curr_view = &lwin;
other_view = &rwin;
init_commands();
}
SETUP()
{
view_setup(&lwin);
view_setup(&rwin);
curr_view = &lwin;
other_view = &rwin;
#ifndef _WIN32
replace_string(&cfg.shell, "/bin/sh");
#else
replace_string(&cfg.shell, "cmd");
#endif
stats_update_shell_type(cfg.shell);
init_commands();
}
SETUP()
{
curr_view = &lwin;
other_view = &rwin;
init_commands();
lwin.dir_entry = NULL;
lwin.list_rows = 0;
lwin.window_rows = 1;
lwin.sort[0] = SK_NONE;
ui_view_sort_list_ensure_well_formed(&lwin, lwin.sort);
lwin.columns = columns_create();
lwin.view_columns = strdup("");
lwin.num_width_g = 4;
lwin.num_width = 4;
lwin.ls_view = 0;
lwin.hide_dot = 1;
lwin.hide_dot_g = 1;
update_string(&lwin.sort_groups, "");
update_string(&lwin.sort_groups_g, "");
rwin.dir_entry = NULL;
rwin.list_rows = 0;
rwin.window_rows = 1;
rwin.sort[0] = SK_NONE;
ui_view_sort_list_ensure_well_formed(&rwin, rwin.sort);
rwin.columns = columns_create();
rwin.view_columns = strdup("");
rwin.num_width_g = 4;
rwin.num_width = 4;
rwin.ls_view = 0;
rwin.hide_dot_g = 1;
rwin.hide_dot = 1;
/* Name+size matches default column view setting ("-{name},{}"). */
columns_add_column_desc(SK_BY_NAME, &format_none);
columns_add_column_desc(SK_BY_SIZE, &format_none);
columns_set_line_print_func(&print_func);
opt_handlers_setup();
}
static const struct subcommand *find_subcmd(const char *cmd, const char *subcmd)
{
int i, j;
const struct command *commands;
const struct subcommand *sub;
init_commands(&commands);
for (i = 0; commands[i].name; i++) {
if (!strcmp(commands[i].name, cmd)) {
sub = commands[i].sub;
for (j = 0; sub[j].name; j++) {
if (!strcmp(sub[j].name, subcmd))
return &sub[j];
}
}
}
return NULL;
}
/**
* \fn int main ()
* \brief entry of the smtpd process
*/
int
main ()
{
struct sigaction sa;
memset (&sa, 0, sizeof (sigaction));
sigemptyset (&sa.sa_mask);
sa.sa_sigaction = segfault_sigaction;
sa.sa_flags = SA_SIGINFO;
// sigaction (SIGSEGV, &sa, NULL);
setvbuf (stdin, NULL, _IONBF, 0);
loadConfig ();
init_commands ();
plugins_table = NULL;
loadAllPlugin ("etc/plugins");
sayWelcome (220);
mainLoop ();
return 0;
}
static int poclidek_init(struct poclidek_ctx *cctx, struct poldek_ctx *ctx)
{
tn_hash *htcnf;
n_assert(cctx->ctx == NULL);
cctx->_flags = 0;
cctx->ctx = poldek_link(ctx);
cctx->pkgs_available = NULL;
cctx->pkgs_installed = NULL;
cctx->_dent_na = n_alloc_new(32, TN_ALLOC_OBSTACK);
cctx->_dent_alloc = dent_alloc;
cctx->rootdir = pkg_dent_add_dir(cctx, NULL, "/");
cctx->currdir = cctx->rootdir;
cctx->homedir = NULL;
cctx->htcnf = htcnf = loadconf();
init_commands(cctx,
htcnf? poldek_conf_get_section(htcnf, "global_aliases"):NULL,
htcnf? poldek_conf_get_section(htcnf, "aliases"):NULL);
return 1;
}
int dvrmain(void)
{
int r;
unsigned short cpu_id;
char commandline[MAX_COMMANDLINE_LENGTH];
init_printf(NULL, _putc);
init_commands();
printf("\n");
info(0, NULL);
/* check CPU ID */
cpu_id = REG32(RTGALAXY_SB2_CHIP_ID) & 0xffff;
if (cpu_id != RTGALAXY_MARS) {
printf("Wrong CPU ID detected (%04X) - aborting\n", cpu_id);
return -1;
}
for (;;) {
printf("rtdsr> ");
r = get_command(commandline, MAX_COMMANDLINE_LENGTH, -1);
if (r > 0) {
if ((r = parse_command(commandline)) < 0 ) {
if (r == PROGRAM_EXIT) {
return 0;
}
printf("error %d executing command\n", r);
}
}
}
return 0;
}
SETUP()
{
init_commands();
view_setup(&lwin);
lwin.columns = columns_create();
lwin.num_width_g = lwin.num_width = 4;
lwin.hide_dot_g = lwin.hide_dot = 1;
curr_view = &lwin;
view_setup(&rwin);
rwin.columns = columns_create();
rwin.num_width_g = rwin.num_width = 4;
rwin.hide_dot_g = rwin.hide_dot = 1;
other_view = &rwin;
/* Name+size matches default column view setting ("-{name},{}"). */
columns_setup_column(SK_BY_NAME);
columns_setup_column(SK_BY_SIZE);
columns_set_line_print_func(&print_func);
opt_handlers_setup();
}
void
init(
int argc,
char **argv)
{
int c, flags = 0;
char *sp;
mode_t mode = 0600;
xfs_fsop_geom_t geometry = { 0 };
progname = basename(argv[0]);
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
pagesize = getpagesize();
gettimeofday(&stopwatch, NULL);
while ((c = getopt(argc, argv, "ac:dFfmp:nrRstVx")) != EOF) {
switch (c) {
case 'a':
flags |= IO_APPEND;
break;
case 'c':
add_user_command(optarg);
break;
case 'd':
flags |= IO_DIRECT;
break;
case 'F':
/* Ignored / deprecated now, handled automatically */
break;
case 'f':
flags |= IO_CREAT;
break;
case 'm':
mode = strtoul(optarg, &sp, 0);
if (!sp || sp == optarg) {
fprintf(stderr, _("non-numeric mode -- %s\n"),
optarg);
exit(1);
}
break;
case 'n':
flags |= IO_NONBLOCK;
break;
case 'p':
progname = optarg;
break;
case 'r':
flags |= IO_READONLY;
break;
case 's':
flags |= IO_OSYNC;
break;
case 't':
flags |= IO_TRUNC;
break;
case 'R':
flags |= IO_REALTIME;
break;
case 'x':
expert = 1;
break;
case 'V':
printf(_("%s version %s\n"), progname, VERSION);
exit(0);
default:
usage();
}
}
while (optind < argc) {
if ((c = openfile(argv[optind], &geometry, flags, mode)) < 0)
exit(1);
if (!platform_test_xfs_fd(c))
flags |= IO_FOREIGN;
if (addfile(argv[optind], c, &geometry, flags) < 0)
exit(1);
optind++;
}
init_commands();
add_args_command(init_args_command);
add_check_command(init_check_command);
}
SETUP()
{
reset_cmds();
init_commands();
}
int main(int argc, char **argv)
{
int ch, longindex, ret;
unsigned long flags;
struct option *long_options;
const struct command *commands;
const char *short_options;
char *p;
const struct sd_option *sd_opts;
install_crash_handler(crash_handler);
init_commands(&commands);
if (argc < 3)
usage(commands, 0);
flags = setup_commands(commands, argv[1], argv[2]);
optind = 3;
sd_opts = build_sd_options(command_opts);
long_options = build_long_options(sd_opts);
short_options = build_short_options(sd_opts);
while ((ch = getopt_long(argc, argv, short_options, long_options,
&longindex)) >= 0) {
switch (ch) {
case 'a':
sdhost = optarg;
break;
case 'p':
sdport = strtol(optarg, &p, 10);
if (optarg == p || sdport < 1 || sdport > UINT16_MAX) {
fprintf(stderr, "Invalid port number '%s'\n", optarg);
exit(EXIT_USAGE);
}
break;
case 'r':
raw_output = true;
break;
case 'h':
subcommand_usage(argv[1], argv[2], EXIT_SUCCESS);
break;
case '?':
usage(commands, EXIT_USAGE);
break;
default:
if (command_parser)
command_parser(ch, optarg);
else
usage(commands, EXIT_USAGE);
break;
}
}
if (!is_stdout_console() || raw_output)
highlight = false;
if (flags & SUBCMD_FLAG_NEED_NODELIST) {
ret = update_node_list(SD_MAX_NODES, 0);
if (ret < 0) {
fprintf(stderr, "Failed to get node list\n");
exit(EXIT_SYSFAIL);
}
}
if (flags & SUBCMD_FLAG_NEED_ARG && argc == optind)
subcommand_usage(argv[1], argv[2], EXIT_USAGE);
return command_fn(argc, argv);
}
void
init(
int argc,
char **argv)
{
xfs_sb_t *sbp;
void *bufp = NULL;
int c;
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
progname = basename(argv[0]);
while ((c = getopt(argc, argv, "c:fFip:rxVl:")) != EOF) {
switch (c) {
case 'c':
cmdline = xrealloc(cmdline, (ncmdline+1)*sizeof(char*));
cmdline[ncmdline++] = optarg;
break;
case 'f':
x.disfile = 1;
break;
case 'F':
force = 1;
break;
case 'i':
x.isreadonly = (LIBXFS_ISREADONLY|LIBXFS_ISINACTIVE);
break;
case 'p':
progname = optarg;
break;
case 'r':
x.isreadonly = LIBXFS_ISREADONLY;
break;
case 'l':
x.logname = optarg;
break;
case 'x':
expert_mode = 1;
break;
case 'V':
printf(_("%s version %s\n"), progname, VERSION);
exit(0);
case '?':
usage();
/*NOTREACHED*/
}
}
if (optind + 1 != argc) {
usage();
/*NOTREACHED*/
}
fsdevice = argv[optind];
if (!x.disfile)
x.volname = fsdevice;
else
x.dname = fsdevice;
if (!libxfs_init(&x)) {
fputs(_("\nfatal error -- couldn't initialize XFS library\n"),
stderr);
exit(1);
}
if (read_bbs(XFS_SB_DADDR, 1, &bufp, NULL)) {
fprintf(stderr, _("%s: %s is invalid (cannot read first 512 "
"bytes)\n"), progname, fsdevice);
exit(1);
}
/* copy SB from buffer to in-core, converting architecture as we go */
libxfs_sb_from_disk(&xmount.m_sb, bufp);
xfree(bufp);
sbp = &xmount.m_sb;
if (sbp->sb_magicnum != XFS_SB_MAGIC) {
fprintf(stderr, _("%s: %s is not a valid XFS filesystem (unexpected SB magic number 0x%08x)\n"),
progname, fsdevice, sbp->sb_magicnum);
if (!force)
exit(EXIT_FAILURE);
}
mp = libxfs_mount(&xmount, sbp, x.ddev, x.logdev, x.rtdev,
LIBXFS_MOUNT_ROOTINOS | LIBXFS_MOUNT_DEBUGGER);
if (!mp) {
mp = libxfs_mount(&xmount, sbp, x.ddev, x.logdev, x.rtdev,
LIBXFS_MOUNT_DEBUGGER);
if (!mp) {
fprintf(stderr, _("%s: device %s unusable (not an XFS "
"filesystem?)\n"), progname, fsdevice);
exit(1);
}
}
blkbb = 1 << mp->m_blkbb_log;
push_cur();
init_commands();
init_sig();
}
int main(int argc, char **argv)
{
int ch, longindex, ret;
unsigned long flags;
struct option *long_options;
const struct command *commands;
const char *short_options;
char *p, *env;
const struct sd_option *sd_opts;
uint8_t sdhost[16];
int sdport;
struct timespec start, end;
start = get_time_tick();
log_dog_operation(argc, argv);
install_crash_handler(crash_handler);
init_commands(&commands);
if (argc < 2)
usage(commands, 0);
flags = setup_commands(commands, argv[1], argv[2]);
optind = 3;
sd_opts = build_sd_options(command_opts);
long_options = build_long_options(sd_opts);
short_options = build_short_options(sd_opts);
env = getenv("SHEEPDOG_DOG_ADDR");
if (env) {
if (!str_to_addr(env, sdhost)) {
sd_err("Invalid ip address %s", env);
return EXIT_FAILURE;
}
memcpy(sd_nid.addr, sdhost, sizeof(sdhost));
}
env = getenv("SHEEPDOG_DOG_PORT");
if (env) {
sdport = strtol(env, &p, 10);
if (env == p || sdport < 1 || sdport > UINT16_MAX
|| !is_numeric(env)) {
sd_err("Invalid port number '%s'", env);
exit(EXIT_USAGE);
}
sd_nid.port = sdport;
}
while ((ch = getopt_long(argc, argv, short_options, long_options,
&longindex)) >= 0) {
switch (ch) {
case 'a':
if (!str_to_addr(optarg, sdhost)) {
sd_err("Invalid ip address %s", optarg);
return EXIT_FAILURE;
}
memcpy(sd_nid.addr, sdhost, sizeof(sdhost));
break;
case 'p':
sdport = strtol(optarg, &p, 10);
if (optarg == p || sdport < 1 || sdport > UINT16_MAX
|| !is_numeric(optarg)) {
sd_err("Invalid port number '%s'", optarg);
exit(EXIT_USAGE);
}
sd_nid.port = sdport;
break;
case 'r':
raw_output = true;
break;
case 'v':
verbose = true;
break;
case 'h':
subcommand_usage(argv[1], argv[2], EXIT_SUCCESS);
break;
case 'T':
elapsed_time = true;
break;
case '?':
usage(commands, EXIT_USAGE);
break;
default:
if (command_parser)
command_parser(ch, optarg);
else
usage(commands, EXIT_USAGE);
break;
}
}
if (sd_inode_actor_init(dog_bnode_writer, dog_bnode_reader) < 0)
exit(EXIT_SYSFAIL);
if (!is_stdout_console() || raw_output)
highlight = false;
if (flags & CMD_NEED_NODELIST) {
ret = update_node_list(SD_MAX_NODES);
if (ret < 0) {
sd_err("Failed to get node list");
exit(EXIT_SYSFAIL);
}
}
if (flags & CMD_NEED_ARG && argc == optind)
subcommand_usage(argv[1], argv[2], EXIT_USAGE);
if (init_event(EPOLL_SIZE) < 0)
exit(EXIT_SYSFAIL);
if (wq_trace_init() < 0)
exit(EXIT_SYSFAIL);
if (init_work_queue(get_nr_nodes) != 0) {
sd_err("Failed to init work queue");
exit(EXIT_SYSFAIL);
}
if (sockfd_init()) {
sd_err("sockfd_init() failed");
exit(EXIT_SYSFAIL);
}
ret = command_fn(argc, argv);
if (ret == EXIT_USAGE)
subcommand_usage(argv[1], argv[2], EXIT_USAGE);
if (elapsed_time) {
end = get_time_tick();
printf("\nElapsed time: %.3lf seconds\n",
get_time_interval(&start, &end));
}
return ret;
}
static void
prepare_cmdline_mode(const wchar_t *prompt, const wchar_t *cmd,
complete_cmd_func complete)
{
line_width = getmaxx(stdscr);
prev_mode = *mode;
*mode = CMDLINE_MODE;
input_stat.line = NULL;
input_stat.index = wcslen(cmd);
input_stat.curs_pos = 0;
input_stat.len = input_stat.index;
input_stat.cmd_pos = -1;
input_stat.complete_continue = 0;
input_stat.history_search = HIST_NONE;
input_stat.line_buf = NULL;
input_stat.reverse_completion = 0;
input_stat.complete = complete;
input_stat.search_mode = 0;
if(sub_mode == SEARCH_FORWARD_SUBMODE
|| sub_mode == VSEARCH_FORWARD_SUBMODE
|| sub_mode == MENU_SEARCH_FORWARD_SUBMODE
|| sub_mode == SEARCH_BACKWARD_SUBMODE
|| sub_mode == VSEARCH_BACKWARD_SUBMODE
|| sub_mode == MENU_SEARCH_BACKWARD_SUBMODE)
{
input_stat.search_mode = 1;
if(prev_mode != MENU_MODE)
{
input_stat.old_top = curr_view->top_line;
input_stat.old_pos = curr_view->list_pos;
}
else
{
save_menu_pos();
}
}
wcsncpy(input_stat.prompt, prompt, ARRAY_LEN(input_stat.prompt));
input_stat.prompt_wid = input_stat.curs_pos = wcslen(input_stat.prompt);
if(input_stat.len != 0)
{
input_stat.line = malloc(sizeof(wchar_t)*(input_stat.len + 1));
if(input_stat.line == NULL)
{
input_stat.index = 0;
input_stat.len = 0;
}
else
{
wcscpy(input_stat.line, cmd);
input_stat.curs_pos += input_stat.len;
}
}
curs_set(TRUE);
update_cmdline_size();
update_cmdline_text();
curr_stats.save_msg = 1;
if(prev_mode == NORMAL_MODE)
init_commands();
}
int
main(int argc, char *argv[])
{
/* TODO: refactor main() function */
char dir[PATH_MAX];
char lwin_path[PATH_MAX] = "";
char rwin_path[PATH_MAX] = "";
int lwin_handle = 0, rwin_handle = 0;
int old_config;
int no_configs;
init_config();
if(is_in_string_array(argv + 1, argc - 1, "--logging"))
{
init_logger(1);
}
(void)setlocale(LC_ALL, "");
if(getcwd(dir, sizeof(dir)) == NULL)
{
perror("getcwd");
return -1;
}
#ifdef _WIN32
to_forward_slash(dir);
#endif
init_filelists();
init_registers();
set_config_paths();
reinit_logger();
init_commands();
init_builtin_functions();
update_path_env(1);
if(init_status() != 0)
{
puts("Error during session status initialization.");
return -1;
}
no_configs = is_in_string_array(argv + 1, argc - 1, "--no-configs");
/* Tell file type module what function to use to check availability of
* external programs. */
config_filetypes(&external_command_exists);
/* This should be called before loading any configuration file. */
reset_all_file_associations(curr_stats.env_type == ENVTYPE_EMULATOR_WITH_X);
init_option_handlers();
old_config = is_old_config();
if(!old_config && !no_configs)
read_info_file(0);
ipc_pre_init();
parse_args(argc, argv, dir, lwin_path, rwin_path, &lwin_handle, &rwin_handle);
ipc_init(&parse_recieved_arguments);
init_background();
set_view_path(&lwin, lwin_path);
set_view_path(&rwin, rwin_path);
/* Force view switch when path is specified for invisible pane. */
if(lwin_path[0] != '\0' && rwin_path[0] == '\0' && curr_view != &lwin)
{
change_window();
}
load_initial_directory(&lwin, dir);
load_initial_directory(&rwin, dir);
/* Force split view when two paths are specified on command-line. */
if(lwin_path[0] != '\0' && rwin_path[0] != '\0')
{
curr_stats.number_of_windows = 2;
}
/* Setup the ncurses interface. */
if(!setup_ncurses_interface())
return -1;
colmgr_init(COLOR_PAIRS);
init_modes();
init_undo_list(&perform_operation, NULL, &cfg.undo_levels);
load_local_options(curr_view);
curr_stats.load_stage = 1;
if(!old_config && !no_configs)
{
load_scheme();
source_config();
}
write_color_scheme_file();
setup_signals();
if(old_config && !no_configs)
{
convert_configs();
curr_stats.load_stage = 0;
read_info_file(0);
curr_stats.load_stage = 1;
set_view_path(&lwin, lwin_path);
set_view_path(&rwin, rwin_path);
load_initial_directory(&lwin, dir);
load_initial_directory(&rwin, dir);
source_config();
}
(void)create_trash_dir(cfg.trash_dir);
check_path_for_file(&lwin, lwin_path, lwin_handle);
check_path_for_file(&rwin, rwin_path, rwin_handle);
curr_stats.load_stage = 2;
exec_startup_commands(argc, argv);
update_screen(UT_FULL);
modes_update();
/* Update histories of the views to ensure that their current directories,
* which might have been set using command-line parameters, are stored in the
* history. This is not done automatically as history manipulation should be
* postponed until views are fully loaded, otherwise there is no correct
* information about current file and relative cursor position. */
save_view_history(&lwin, NULL, NULL, -1);
save_view_history(&rwin, NULL, NULL, -1);
curr_stats.load_stage = 3;
main_loop();
return 0;
}
int main(int argc, char **argv)
{
int ch, longindex, ret;
unsigned long flags;
struct option *long_options;
const struct command *commands;
const char *short_options;
char *p;
const struct sd_option *sd_opts;
uint8_t sdhost[16];
int sdport;
log_dog_operation(argc, argv);
install_crash_handler(crash_handler);
init_commands(&commands);
if (argc < 2)
usage(commands, 0);
flags = setup_commands(commands, argv[1], argv[2]);
optind = 3;
sd_opts = build_sd_options(command_opts);
long_options = build_long_options(sd_opts);
short_options = build_short_options(sd_opts);
while ((ch = getopt_long(argc, argv, short_options, long_options,
&longindex)) >= 0) {
switch (ch) {
case 'a':
if (!str_to_addr(optarg, sdhost)) {
sd_err("Invalid ip address %s", optarg);
return EXIT_FAILURE;
}
memcpy(sd_nid.addr, sdhost, sizeof(sdhost));
break;
case 'p':
sdport = strtol(optarg, &p, 10);
if (optarg == p || sdport < 1 || sdport > UINT16_MAX) {
sd_err("Invalid port number '%s'", optarg);
exit(EXIT_USAGE);
}
sd_nid.port = sdport;
break;
case 'r':
raw_output = true;
break;
case 'v':
verbose = true;
break;
case 'h':
subcommand_usage(argv[1], argv[2], EXIT_SUCCESS);
break;
case '?':
usage(commands, EXIT_USAGE);
break;
default:
if (command_parser)
command_parser(ch, optarg);
else
usage(commands, EXIT_USAGE);
break;
}
}
if (!is_stdout_console() || raw_output)
highlight = false;
if (flags & CMD_NEED_NODELIST) {
ret = update_node_list(SD_MAX_NODES);
if (ret < 0) {
sd_err("Failed to get node list");
exit(EXIT_SYSFAIL);
}
}
if (flags & CMD_NEED_ARG && argc == optind)
subcommand_usage(argv[1], argv[2], EXIT_USAGE);
if (init_event(EPOLL_SIZE) < 0)
exit(EXIT_SYSFAIL);
if (init_work_queue(get_nr_nodes) != 0) {
sd_err("Failed to init work queue");
exit(EXIT_SYSFAIL);
}
if (sockfd_init()) {
sd_err("sockfd_init() failed");
exit(EXIT_SYSFAIL);
}
ret = command_fn(argc, argv);
if (ret == EXIT_USAGE)
subcommand_usage(argv[1], argv[2], EXIT_USAGE);
return ret;
}
int start_server()
{
int child_indx, pid, i, ctl_socket;
int childs, freeservers, used, maxrequests, ret;
char command_buffer[COMMANDS_BUFFER_SIZE];
int user_informed = 0;
ctl_socket = ci_named_pipe_create(CONF.COMMANDS_SOCKET);
if (ctl_socket < 0) {
ci_debug_printf(1,
"Error opening control socket %s. Fatal error, exiting!\n",
CONF.COMMANDS_SOCKET);
exit(0);
}
if (!ci_proc_mutex_init(&accept_mutex)) {
ci_debug_printf(1,
"Can't init mutex for accepting conenctions. Fatal error, exiting!\n");
exit(0);
}
childs_queue = malloc(sizeof(struct childs_queue));
if (!create_childs_queue(childs_queue, 2 * CONF.MAX_SERVERS)) {
ci_proc_mutex_destroy(&accept_mutex);
ci_debug_printf(1,
"Can't init shared memory. Fatal error, exiting!\n");
exit(0);
}
init_commands();
pid = 1;
#ifdef MULTICHILD
if (CONF.START_SERVERS > CONF.MAX_SERVERS)
CONF.START_SERVERS = CONF.MAX_SERVERS;
for (i = 0; i < CONF.START_SERVERS; i++) {
if (pid)
pid = start_child(LISTEN_SOCKET);
}
if (pid != 0) {
main_signals();
while (1) {
if ((ret = wait_for_commands(ctl_socket, command_buffer, 1)) > 0) {
ci_debug_printf(5, "I received the command: %s\n",
command_buffer);
handle_monitor_process_commands(command_buffer);
}
if (ret < 0) { /*Eof received on pipe. Going to reopen ... */
ci_named_pipe_close(ctl_socket);
ctl_socket = ci_named_pipe_open(CONF.COMMANDS_SOCKET);
if (ctl_socket < 0) {
ci_debug_printf(1,
"Error opening control socket. We are unstable and going down!");
c_icap_going_to_term = 1;
}
}
if (c_icap_going_to_term)
break;
childs_queue_stats(childs_queue, &childs, &freeservers, &used,
&maxrequests);
ci_debug_printf(10,
"Server stats: \n\t Children: %d\n\t Free servers: %d\n"
"\tUsed servers:%d\n\tRequests served:%d\n",
childs, freeservers, used, maxrequests);
if (MAX_REQUESTS_PER_CHILD > 0 && (child_indx =
find_a_child_nrequests
(childs_queue,
MAX_REQUESTS_PER_CHILD)) >=
0) {
ci_debug_printf(8,
"Max requests reached for child :%d of pid :%d\n",
child_indx,
childs_queue->childs[child_indx].pid);
pid = start_child(LISTEN_SOCKET);
// usleep(500);
childs_queue->childs[child_indx].father_said = GRACEFULLY;
/*kill a server ... */
kill(childs_queue->childs[child_indx].pid, SIGTERM);
}
else if ((freeservers <= CONF.MIN_SPARE_THREADS && childs < CONF.MAX_SERVERS)
|| childs < CONF.START_SERVERS) {
ci_debug_printf(8,
"Free Servers: %d, children: %d. Going to start a child .....\n",
freeservers, childs);
pid = start_child(LISTEN_SOCKET);
}
else if (freeservers >= CONF.MAX_SPARE_THREADS &&
childs > CONF.START_SERVERS &&
(freeservers - CONF.THREADS_PER_CHILD) > CONF.MIN_SPARE_THREADS) {
if ((child_indx = find_an_idle_child(childs_queue)) >= 0) {
childs_queue->childs[child_indx].father_said =
GRACEFULLY;
ci_debug_printf(8,
"Free Servers: %d, children: %d. Going to stop child %d(index: %d)\n",
freeservers, childs,
childs_queue->childs[child_indx].pid,
child_indx);
/*kill a server ... */
kill(childs_queue->childs[child_indx].pid, SIGTERM);
user_informed = 0;
}
}
else if (childs == CONF.MAX_SERVERS && freeservers < CONF.MIN_SPARE_THREADS) {
if(! user_informed) {
ci_debug_printf(1,
"ATTENTION!!!! Not enough available servers (children %d, free servers %d, used servers %d)!!!!! "
"Maybe you should increase the MaxServers and the "
"ThreadsPerChild values in c-icap.conf file!!!!!!!!!",childs , freeservers, used);
user_informed = 1;
}
}
if (c_icap_going_to_term)
break;
check_for_exited_childs();
if (c_icap_reconfigure) {
c_icap_reconfigure = 0;
if (!server_reconfigure()) {
ci_debug_printf(1, "Error while reconfiguring, exiting!\n");
break;
}
}
}
/*Main process exit point */
ci_debug_printf(1,
"Possibly a term signal received. Monitor process going to term all children\n");
kill_all_childs();
system_shutdown();
ci_debug_printf(1, "Exiting....\n");
return 1;
}
#else
child_data = (child_shared_data_t *) malloc(sizeof(child_shared_data_t));
child_data->pid = 0;
child_data->freeservers = CONF.THREADS_PER_CHILD;
child_data->usedservers = 0;
child_data->requests = 0;
child_data->connections = 0;
child_data->to_be_killed = 0;
child_data->father_said = 0;
child_data->idle = 1;
child_data->stats_size = ci_stat_memblock_size();
child_data->stats = malloc(child_data->stats_size);
child_data->stats->sig = MEMBLOCK_SIG;
ci_stat_attach_mem(child_data->stats, child_data->stats_size, NULL);
child_main(LISTEN_SOCKET, 0);
ci_proc_mutex_destroy(&accept_mutex);
destroy_childs_queue(childs_queue);
#endif
return 1;
}
SETUP()
{
init_commands();
}
