void redemption_main_loop(Inifile & ini, unsigned uid, unsigned gid)
{
init_signals();
SessionServer ss(&refreshconf, uid, gid);
// Inifile ini(CFG_PATH "/" RDPPROXY_INI);
uint32_t s_addr = inet_addr(ini.globals.listen_address);
if (s_addr == INADDR_NONE) { s_addr = INADDR_ANY; }
int port = ini.globals.port;
Listen listener(ss, s_addr, port);
listener.run();
}
void start_main(int argc, char** argv, char** envp)
{
init_process_malloc();
init_stdfiles();
init_signals();
init_environ(envp);
exit(main(argc, argv));
}
int main(int argc, char *argv[])
{
pid_t pid;
#ifdef SIGNAL
init_signals();
#endif
if (argc == 2) {
usage();
return 0;
}
if (argc == 3) {
if (!strcmp(argv[1], "-i")) {
if (getIfIsUp(argv[2]) == 1)
strcpy(IF_NAME, argv[2]);
else
return 0;
} else {
usage();
return 0;
}
} else {
strcpy(IF_NAME, "ra0");
}
/* background ourself */
if (do_fork) {
pid = fork();
} else {
pid = getpid();
}
switch (pid) {
case -1:
/* error */
perror("fork/getpid");
return -1;
case 0:
/* child, success */
break;
default:
/* parent, success */
if (do_fork)
return 0;
break;
}
RaCfg_Agent();
return 0;
}
void attach_debug() {
#ifndef RUMBLE_MSC
init_signals();
#else
signal(SIGINT, &signal_windows);
signal(SIGBREAK, &signal_windows);
signal(SIGSEGV, &signal_windows);
signal(SIGTERM, &signal_windows);
signal(SIGABRT, &signal_windows);
signal(SIGILL, &signal_windows);
atexit(&cleanup);
#endif
}
int main(void)
{
t_env *env;
char buffer[20];
init_signals();
tgetent(0, getenv("TERM"));
if (!(env = malloc(sizeof(*env))))
quit("Failed to malloc env");
if (!(env->caps = malloc(sizeof(*env->caps))))
quit("Failed to malloc env caps");
env->messages = NULL;
if (!(env->input = ft_memalloc(1)))
quit("Failed to malloc new input");
init_caps(env->caps);
terminal_catch_mode();
ft_putstr(env->caps->fullscreen_start);
ft_putstr(env->caps->clear);
ft_putstr(env->caps->stand_start);
ft_putstr(env->caps->bold_start);
int i = 0;
set_cursor_position(env, 0, get_window_height() - 2);
int width = get_window_width();
while (i < width)
{
ft_putchar('-');
i++;
}
ft_putstr(env->caps->stand_end);
fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
int t = 0;
int rd;
while (t < 50)
{
ft_bzero(buffer, 20);
while ((rd = read(0, buffer, 20)) < 1)
{
if (errno != EAGAIN && errno != EWOULDBLOCK)
quit("Error on stdin read");
//check tcp
//check resize
}
ft_putstr(buffer);
t++;
}
fcntl(0, F_SETFL, fcntl(0, F_GETFL) & ~O_NONBLOCK);
ft_putstr(env->caps->fullscreen_end);
terminal_normal_mode();
return (0);
}
void handle_int(int UN signal)
{
t_term *s_term;
if ((s_term = static_term(NULL)))
{
waddstr(s_term->slave.wins[WIN_SH], "^C");
if (s_term->line)
clear_line(s_term->line);
s_term->line = NULL;
s_term->intr = 1;
}
init_signals();
}
int main(int argc, char *argv[])
{
int rc;
int interractive = 0;
boost();
init_signals();
while (argc > 1) {
char *arg = argv[--argc];
if (*arg=='-' && *(arg+1)=='i') {
interractive = 1;
} else if (*arg=='-' && *(arg+1)=='p') {
pj_str_t port = pj_str(argv[--argc]);
param_echo_port = pj_strtoul(&port);
} else if (*arg=='-' && *(arg+1)=='s') {
param_echo_server = argv[--argc];
} else if (*arg=='-' && *(arg+1)=='t') {
pj_str_t type = pj_str(argv[--argc]);
if (pj_stricmp2(&type, "tcp")==0)
param_echo_sock_type = pj_SOCK_STREAM();
else if (pj_stricmp2(&type, "udp")==0)
param_echo_sock_type = pj_SOCK_DGRAM();
else {
PJ_LOG(3,("", "error: unknown socket type %s", type.ptr));
return 1;
}
}
}
rc = test_main();
if (interractive) {
char s[10];
puts("");
puts("Press <ENTER> to exit");
if (!fgets(s, sizeof(s), stdin))
return rc;
}
return rc;
}
/* Get things started */
void init_factor(F_PARAMETERS *p)
{
/* Kilobytes */
p->ds_size = align_page(p->ds_size << 10);
p->rs_size = align_page(p->rs_size << 10);
/* Megabytes */
p->young_size <<= 20;
p->aging_size <<= 20;
p->tenured_size <<= 20;
p->code_size <<= 20;
/* Disable GC during init as a sanity check */
gc_off = true;
/* OS-specific initialization */
early_init();
if(p->image == NULL)
p->image = default_image_path();
srand(current_micros());
init_ffi();
init_stacks(p->ds_size,p->rs_size);
load_image(p);
init_c_io();
init_signals();
if(p->console)
open_console();
stack_chain = NULL;
profiling_p = false;
performing_gc = false;
last_code_heap_scan = NURSERY;
collecting_aging_again = false;
userenv[CPU_ENV] = tag_object(from_char_string(FACTOR_CPU_STRING));
userenv[OS_ENV] = tag_object(from_char_string(FACTOR_OS_STRING));
userenv[CELL_SIZE_ENV] = tag_fixnum(sizeof(CELL));
userenv[STACK_TRACES_ENV] = tag_boolean(p->stack_traces);
/* We can GC now */
gc_off = false;
if(!stage2)
do_stage1_init();
}
int jed_spawn_fg_process (int (*f)(VOID_STAR), VOID_STAR cd)
{
int status;
int inited;
if ((Jed_Secure_Mode)
|| (Jed_Suspension_Not_Allowed))
{
msg_error ("Access to shell denied.");
return -1;
}
/* FIXME: X_Suspend_Hook should not be here. Currently, this hook is
* used only by GUI jed, where suspension makes no sense. Of course in
* this case, spawning a foreground process also does not make sense.
*/
if (Batch || (X_Suspend_Hook != NULL))
return (*f) (cd);
SLsig_block_signals ();
inited = Jed_Display_Initialized;
SLsig_unblock_signals ();
jed_reset_display();
#if !defined(IBMPC_SYSTEM) && !defined(VMS)
jed_reset_signals ();
#endif
reset_tty();
status = (*f) (cd);
if (inited)
{
#if !defined(IBMPC_SYSTEM) && !defined(VMS)
init_signals();
#endif
if (-1 == init_tty())
{
exit_error ("Unable to initialize terminal.", 0);
}
flush_input ();
jed_init_display ();
}
check_buffers();
return status;
}
int main(int ac, char **arv)
{
int error;
#ifdef DEBUG
/* logfile=/var/log/log.txt */
create_log();
fprintf(log_path, "ac = %d\n", ac);
fflush(log_path);
#endif
/* setup signal handlers */
init_signals();
/* printer DEVICE ID and command line option check */
if((error = get_printer_devid()) < 0 || check_arg(ac,arv) < 0){
/*
Not Canon printer
or
"--gui" option not found
*/
#ifdef DEBUG
write_log("Now normal printing ......\n");
#endif
print_normal();
exit(0);
}
/* create semapho and other setup */
if((error = lm_init(PRNT_PATH))){
exit(0);
}
/* monitor_process/print_process/status_process start */
lm_main_fork();
/* delete semapho */
remove_sem(sem_id);
/* free memory (status monitor argv string) */
free_arg();
#ifdef DEBUG
write_log("LM end \n");
#endif
exit(0);
}
int main(void) {
// Vars
struct fp_dev *device;
struct fp_driver *driver;
struct fp_print_data *print_data;
struct fp_img *img;
int err;
// Init the LCD
lcdinit(0x00, 0x12, 0x20);
lcd_reset();
// Init libfprint
fp_init();
// Init the keypad
matrix_init(4, 17, 27, 22, 10, 9, 11, handle_key_press);
// Signal handler - does an fp_exit() on SIGINT
init_signals();
// Get the first fingerprint device
if ((err = get_fingerprint_device(&device)) < 0 || !device) { // Errorz
if (err == -1) {
error("No devices found");
}
else if (err == -2) {
error("Couldn't open the device");
}
return 1;
}
// Get driver
driver = fp_dev_get_driver(device);
// Init message
printf("Programme started! Device is %s\n\n", fp_driver_get_full_name(driver));
// Scan the print
fp_enroll_finger_img(device, &print_data, &img);
// Deinit libfprint
fp_exit();
return 0;
}
int main(int argc, char **argv)
{
bool recovering = false;
int port, control = 0;
init_signals();
/** Get the port number. */
port = 7778;
if (argc > 1) {
if (!is_number(argv[1])) {
fprintf(stderr, "Usage: %s [port #]\n", argv[0]);
return 0;
} else if ((port = atoi(argv[1])) <= 1024) {
fprintf(stderr, "Port number must be above 1024.\n");
return 0;
}
/* Are we recovering from a copyover? */
if ((argv[2] != NULL) && (argv[2][0] != '\0')) {
recovering = true;
control = atoi(argv[3]);
} else {
recovering = false;
}
}
init_time(&globalSystemState);
boot_db();
/** Run the game. */
if (!recovering) {
control = remote_listen(port);
}
log_string("BT is ready to rock on port %d.", port);
if (recovering) {
copyover_recover();
}
game_loop(port, control);
remote_deafen(control);
log_string("Normal termination of game.");
return 0;
}
int create_cmdline_interface (char *prmt)
{
/* init the tty promt properties*/
init_tty_prompt ();
/*signal handlers for SIGINT, SIGSEGV, SIGUSR1, SIGUSR2*/
init_signals();
/*XXX:set the tty prompt - we take control from shell
don't forget to call reset_tty () once your job is done*/
set_tty();
set_prompt(prmt, strlen(prmt));
create_sync_lock (&cmd_root.lock);
/*finally kick-start the shell thread*/
spawn_cli_thread ();
return 0;
}
void redemption_new_session()
{
char text[256];
char ip_source[256];
union
{
struct sockaddr s;
struct sockaddr_storage ss;
struct sockaddr_in s4;
struct sockaddr_in6 s6;
} u;
int sock_len = sizeof(u);
Inifile ini(CFG_PATH "/" RDPPROXY_INI);
init_signals();
snprintf(text, 255, "redemption_%8.8x_main_term", getpid());
getpeername(0, &u.s, (socklen_t *)&sock_len);
strcpy(ip_source, inet_ntoa(u.s4.sin_addr));
int sck = 0;
if (ini.globals.debug.session){
LOG(LOG_INFO, "Setting new session socket to %d\n", sck);
}
int nodelay = 1;
if (0 == setsockopt(sck, IPPROTO_TCP, TCP_NODELAY, (char*)&nodelay, sizeof(nodelay))){
wait_obj front_event(sck);
Session session(front_event, sck, ip_source, &refreshconf, &ini);
if (ini.globals.debug.session){
LOG(LOG_INFO, "Session::end of Session(%u)", sck);
}
shutdown(sck, 2);
close(sck);
}
else {
LOG(LOG_INFO, "Failed to set socket TCP_NODELAY option on client socket");
}
}
void redemption_main_loop(Inifile & ini, unsigned uid, unsigned gid)
{
init_signals();
SessionServer ss(uid, gid);
// Inifile ini(CFG_PATH "/" RDPPROXY_INI);
uint32_t s_addr = inet_addr(ini.globals.listen_address);
if (s_addr == INADDR_NONE) { s_addr = INADDR_ANY; }
int port = ini.globals.port;
Listen listener( ss
, s_addr
, port
, false /* exit on timeout */
, 60 /* timeout sec */
, ini.globals.enable_ip_transparent
);
listener.run();
}
int main(int argc, char **argv) {
int listenfd, port, ret;
struct horse *horses;
unsigned int horse_num, pperh;
pthread_mutex_t mutex, mfinished, mbank, mcur_run, mhb, mnr;
pthread_cond_t cond;
pthread_barrier_t barrier;
struct service service;
if (argc != 3) {
usage(argv[0]);
exit(EXIT_FAILURE);
}
// parse port
port = atoi(argv[1]);
listenfd = init_socket(port);
_listen(listenfd, LISTENQ);
init_sync(&mutex, &cond, &mfinished, &mbank, &mcur_run, &mhb, &mnr);
ret = parse_conf_file(argv[2], &horses, &horse_num, &pperh, &mutex, &cond, &barrier, &service);
if (ret)
goto clean;
if (!pperh || pperh > MAX_RACE_NUM) {
fprintf(stderr, "races per hour %u should be more than 0 and less than %d\n", pperh, MAX_RACE_NUM + 1);
goto clean;
}
init_signals();
srand(time(NULL));
init_service(&service, &mfinished, &mbank, &mcur_run, &mhb, &mnr, (unsigned int)(60 * 60 / pperh));
server_work(listenfd, &cond, &service, horses, horse_num);
clean:
// cleaning
clean(&mutex, &cond, &mfinished, &mbank, &mcur_run, &mhb, &mnr, horses, listenfd);
return EXIT_SUCCESS;
}
int
main(int argc, char **argv)
{
init_signals();
if (init_dbus() < 0) {
fprintf(stderr, "Cannot initialize DBus\n");
return 1;
}
while (dbus_connection_read_write(conn, -1)) {
while (dbus_connection_dispatch(conn) != DBUS_DISPATCH_COMPLETE) {
}
}
shutdown_dbus();
return 0;
}
void startup() {
totalbytes = 0;
printf("Acidblood %s\n", VERSION);
init_conf() ;
init_signals() ;
init_networking() ;
conf_userdata=NULL ;
conf_channels=NULL ;
init_usercommands() ;
init_ctcp() ;
init_srvcommands() ;
init_log();
init_serverinfo() ;
init_numeric() ;
init_timers() ;
init_events() ;
read_main_config() ;
init_modules() ;
}
int main(int argc, char **argv)
{
int fd;
int i;
pid_t pid;
sigset_t set;
mainParseOptions(argc, argv);
printf("yang test ... opt_send_signal:%d\r\n", opt_send_signal);
if (-1 == opt_send_signal)
if (checkRunningPid())
exit(1);
enableCoredumps();
writePidFile();
save_argv(argc, argv);
init_setproctitle();
init_signals();
sigemptyset(&set);
printf("father pid1=%d\n",getpid());
int worker_processes = 3;
start_worker_processes(worker_processes, PROCESS_RESPAWN);
start_dispatcher_process(PROCESS_RESPAWN);
printf("father pid2=%d\n", getpid());
setproctitle("nginx:master");
int live = 1;
for (;;) {
printf("father before suspend\n");
sigsuspend(&set);
printf("father after suspend\n");
if (reap) {
reap = 0;
fprintf(stderr, "reap children\n");
live = reap_children();
}
}
return 0;
}
/* This function is called (via check_events()) from the top level sieve
loops (prime_sieve() etc.). It can assume that it is safe to tighten any
sieving parameters other than p_min and p_max.
*/
void process_events(uint64_t current_prime)
{
/* event_happened was set last in notify_event(), so clear it first which
ensures that if some signal arrives while we are in process_events()
it might have to wait until the next sieve iteration to get processed,
but it won't be lost.
*/
event_happened = 0;
if (clear_event(initialise_events))
{
init_signals();
init_progress_report(current_prime);
}
if (clear_event(subsequence_eliminated))
remove_eliminated_subsequences(current_prime);
if (clear_event(sieve_parameters_changed))
init_progress_report(current_prime);
if (clear_event(received_sigterm))
{
finish_srsieve("SIGTERM was received",current_prime);
signal(SIGTERM,SIG_DFL);
raise(SIGTERM);
}
if (clear_event(received_sigint))
{
finish_srsieve("SIGINT was received",current_prime);
signal(SIGINT,SIG_DFL);
raise(SIGINT);
}
if (clear_event(report_due))
progress_report(current_prime);
if (clear_event(save_due))
write_save_file(current_prime);
}
int main (int argc, char **argv)
{
//初始化必要的资源
if( init_resource() < 0 ){
debug(LOG_ERR, " init_resource fail !");
return -1;
}
parse_commandline(argc, argv);
/* Init the signals to catch chld/quit/etc */
init_signals();
if( do_process() < 0 ) {
debug(LOG_ERR, " do_process fail !");
exit(-1);
}
debug(LOG_ERR, "%s : QUIT do_process()",__FUNCTION__);
return 0;
}
static int init_mysh(t_term *s_term, char **environ)
{
char *env_path;
my_bzero((void *)s_term, sizeof(*s_term));
if (environ && *environ)
{
get_environ(s_term, environ);
static_term(s_term);
init_signals();
s_term->tsave = init_termcap(s_term->environ);
s_term->pid = my_getpid();
s_term->progs = NULL;
if ((env_path = my_getenv(environ, "PATH="))
&& (s_term->progs = get_path_progs(env_path))
&& !add_builtins(s_term->progs))
return (1);
}
return (0);
}
/** Main entry point for nodogsplash.
* Reads the configuration file and then starts the main loop.
*/
int main(int argc, char **argv) {
s_config *config = config_get_config();
config_init();
parse_commandline(argc, argv);
/* Initialize the config */
debug(LOG_NOTICE,"Reading and validating configuration file %s", config->configfile);
config_read(config->configfile);
config_validate();
/* Initializes the linked list of connected clients */
client_list_init();
/* Init the signals to catch chld/quit/etc */
debug(LOG_NOTICE,"Initializing signal handlers");
init_signals();
if (config->daemon) {
debug(LOG_NOTICE, "Starting as daemon, forking to background");
switch(safe_fork()) {
case 0: /* child */
setsid();
main_loop();
break;
default: /* parent */
exit(0);
break;
}
}
else {
main_loop();
}
return(0); /* never reached */
}
void redemption_main_loop(Inifile & ini, CryptoContext & cctx, unsigned uid, unsigned gid, std::string config_filename)
{
init_signals();
SessionServer ss(cctx, uid, gid, std::move(config_filename), ini.get<cfg::debug::config>() == Inifile::ENABLE_DEBUG_CONFIG);
// Inifile ini(CFG_PATH "/" RDPPROXY_INI);
uint32_t s_addr = inet_addr(ini.get<cfg::globals::listen_address>().c_str());
// TODO -Wold-style-cast is ignored
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
if (s_addr == INADDR_NONE) { s_addr = INADDR_ANY; }
#pragma GCC diagnostic pop
int port = ini.get<cfg::globals::port>();
Listen listener( ss
, s_addr
, port
, false /* exit on timeout */
, 60 /* timeout sec */
, ini.get<cfg::globals::enable_ip_transparent>()
);
listener.run();
}
int main(int argc, char **argv)
{
out_bgorlit();
test_hex2pro();
test_pro2hex();
cmd_parser(argc,argv,&glb_cfg);
if(glb_cfg.daemon)
run_as_daemon();
/*
* Make sure only one copy of the daemon is running.
*/
if (already_running()) {
debug(LOG_ERR, "daemon already running\n");
exit(1);
}
pthread_mutex_init(&(glb_cfg.lock), NULL);
pthread_cond_init(&(glb_cfg.cond), NULL);
// init_log(argv[0]);
init_signals();
alarm(WT_SDCARD_PRIOD);
pthread_t sorpid;
pthread_create(&sorpid,NULL,handle_uart,NULL);
pthread_t cmdpid;
pthread_create(&cmdpid,NULL,handle_socket_machine,NULL);
pthread_join(sorpid,NULL);
pthread_join(cmdpid,NULL);
debug(LOG_NOTICE,"<==========Process exit!\n");
// close_log();
return 0;
}
int main(int argc, char *argv[])
{
int rc;
PJ_UNUSED_ARG(argc);
PJ_UNUSED_ARG(argv);
boost();
init_signals();
rc = test_main();
if (argc==2 && pj_ansi_strcmp(argv[1], "-i")==0) {
char s[10];
puts("Press ENTER to quit");
if (fgets(s, sizeof(s), stdin) == NULL)
return rc;
}
return rc;
}
int main( int argc, char *argv[] )
{
parse_args( argc, argv );
/* setup temporary handlers before the real signal initialization is done */
signal( SIGPIPE, SIG_IGN );
signal( SIGHUP, sigterm_handler );
signal( SIGINT, sigterm_handler );
signal( SIGQUIT, sigterm_handler );
signal( SIGTERM, sigterm_handler );
signal( SIGABRT, sigterm_handler );
sock_init();
open_master_socket();
setvbuf( stderr, NULL, _IOLBF, 0 );
if (debug_level) fprintf( stderr, "wineserver: starting (pid=%ld)\n", (long) getpid() );
init_signals();
init_directories();
init_registry();
main_loop();
return 0;
}
int main() {
int argc;
char **argv;
win32_get_argv_utf8(&argc, &argv);
#else
int main(int argc, char **argv) {
#endif
parse_shift_args(&opts, &argc, &argv);
__idris_argc = argc;
__idris_argv = argv;
VM* vm = init_vm(opts.max_stack_size, opts.init_heap_size, 1);
init_threadkeys();
init_threaddata(vm);
init_gmpalloc();
init_nullaries();
init_signals();
_idris__123_runMain0_125_(vm, NULL);
#ifdef IDRIS_DEBUG
if (opts.show_summary) {
idris_gcInfo(vm, 1);
}
#endif
Stats stats = terminate(vm);
if (opts.show_summary) {
print_stats(&stats);
}
free_nullaries();
return EXIT_SUCCESS;
}
int main (int argc, char *argv[])
{
int ch;
bool no_signals = false;
bool test_config = false;
pthread_t thid;
char *uid = NULL;
char *gid = NULL;
start_heap = sbrk(0);
setlocale(LC_ALL, "");
bindtextdomain("bareos", LOCALEDIR);
textdomain("bareos");
init_stack_dump();
my_name_is(argc, argv, "bareos-sd");
init_msg(NULL, NULL);
daemon_start_time = time(NULL);
/* Sanity checks */
if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
TAPE_BSIZE, B_DEV_BSIZE);
}
if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
}
while ((ch = getopt(argc, argv, "c:d:fg:mpstu:v?")) != -1) {
switch (ch) {
case 'c': /* configuration file */
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(optarg);
break;
case 'd': /* debug level */
if (*optarg == 't') {
dbg_timestamp = true;
} else {
debug_level = atoi(optarg);
if (debug_level <= 0) {
debug_level = 1;
}
}
break;
case 'f': /* run in foreground */
foreground = true;
break;
case 'g': /* set group id */
gid = optarg;
break;
case 'm': /* print kaboom output */
prt_kaboom = true;
break;
case 'p': /* proceed in spite of I/O errors */
forge_on = true;
break;
case 's': /* no signals */
no_signals = true;
break;
case 't':
test_config = true;
break;
case 'u': /* set uid */
uid = optarg;
break;
case 'v': /* verbose */
verbose++;
break;
case '?':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc) {
if (configfile != NULL) {
free(configfile);
}
configfile = bstrdup(*argv);
argc--;
argv++;
}
if (argc)
usage();
/*
* See if we want to drop privs.
*/
if (geteuid() == 0) {
drop(uid, gid, false);
}
if (!no_signals) {
init_signals(terminate_stored);
}
if (configfile == NULL) {
configfile = bstrdup(CONFIG_FILE);
}
my_config = new_config_parser();
parse_sd_config(my_config, configfile, M_ERROR_TERM);
if (init_crypto() != 0) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Cryptography library initialization failed.\n"));
}
if (!check_resources()) {
Jmsg((JCR *)NULL, M_ERROR_TERM, 0, _("Please correct configuration file: %s\n"), configfile);
}
init_reservations_lock();
if (test_config) {
terminate_stored(0);
}
my_name_is(0, (char **)NULL, me->hdr.name); /* Set our real name */
if (!foreground) {
daemon_start(); /* become daemon */
init_stack_dump(); /* pick up new pid */
}
create_pid_file(me->pid_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
read_state_file(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
read_crypto_cache(me->working_directory, "bareos-sd",
get_first_port_host_order(me->SDaddrs));
set_jcr_in_tsd(INVALID_JCR);
/*
* Make sure on Solaris we can run concurrent, watch dog + servers + misc
*/
set_thread_concurrency(me->max_concurrent_jobs * 2 + 4);
lmgr_init_thread(); /* initialize the lockmanager stack */
load_sd_plugins(me->plugin_directory, me->plugin_names);
cleanup_old_files();
/* Ensure that Volume Session Time and Id are both
* set and are both non-zero.
*/
VolSessionTime = (uint32_t)daemon_start_time;
if (VolSessionTime == 0) { /* paranoid */
Jmsg0(NULL, M_ABORT, 0, _("Volume Session Time is ZERO!\n"));
}
/*
* Start the device allocation thread
*/
create_volume_lists(); /* do before device_init */
if (pthread_create(&thid, NULL, device_initialization, NULL) != 0) {
berrno be;
Emsg1(M_ABORT, 0, _("Unable to create thread. ERR=%s\n"), be.bstrerror());
}
start_watchdog(); /* start watchdog thread */
if (me->jcr_watchdog_time) {
init_jcr_subsystem(me->jcr_watchdog_time); /* start JCR watchdogs etc. */
}
#if HAVE_NDMP
/* Seperate thread that handles NDMP connections */
if (me->ndmp_enable) {
start_ndmp_thread_server(me->NDMPaddrs,
me->max_concurrent_jobs * 2 + 1,
&ndmp_workq);
}
#endif
/* Single server used for Director/Storage and File daemon */
sock_fds = New(alist(10, not_owned_by_alist));
bnet_thread_server_tcp(me->SDaddrs,
me->max_concurrent_jobs * 2 + 1,
sock_fds,
&dird_workq,
me->nokeepalive,
handle_connection_request);
exit(1); /* to keep compiler quiet */
}
void redemption_new_session(CryptoContext & cctx, char const * config_filename)
{
char text[256];
char source_ip[256];
int target_port = 0;
char real_target_ip[256];
union
{
struct sockaddr s;
struct sockaddr_storage ss;
struct sockaddr_in s4;
struct sockaddr_in6 s6;
} u;
int sock_len = sizeof(u);
Inifile ini;
{ ConfigurationLoader cfg_loader(ini.configuration_holder(), config_filename); }
init_signals();
snprintf(text, 255, "redemption_%8.8x_main_term", unsigned(getpid()));
getpeername(0, &u.s, reinterpret_cast<socklen_t *>(&sock_len));
strcpy(source_ip, inet_ntoa(u.s4.sin_addr));
union
{
struct sockaddr s;
struct sockaddr_storage ss;
struct sockaddr_in s4;
struct sockaddr_in6 s6;
} localAddress;
socklen_t addressLength = sizeof(localAddress);
int sck = 0;
if (-1 == getsockname(sck, &localAddress.s, &addressLength)){
LOG(LOG_INFO, "getsockname failed error=%s", strerror(errno));
_exit(1);
}
target_port = localAddress.s4.sin_port;
strcpy(real_target_ip, inet_ntoa(localAddress.s4.sin_addr));
if (ini.get<cfg::globals::enable_ip_transparent>()) {
const int source_port = 0;
char target_ip[256];
strcpy(target_ip, inet_ntoa(localAddress.s4.sin_addr));
int fd = open("/proc/net/ip_conntrack", O_RDONLY);
// source and dest are inverted because we get the information we want from reply path rule
int res = parse_ip_conntrack(fd, target_ip, source_ip, target_port, source_port, real_target_ip, sizeof(real_target_ip));
if (res){
LOG(LOG_WARNING, "Failed to get transparent proxy target from ip_conntrack");
}
close(fd);
}
ini.set_acl<cfg::globals::host>(source_ip);
ini.set_acl<cfg::globals::target>(real_target_ip);
if (ini.get<cfg::debug::session>()){
LOG(LOG_INFO, "Setting new session socket to %d\n", sck);
}
int nodelay = 1;
if (0 == setsockopt(sck, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*>(&nodelay), sizeof(nodelay))){
Session session(sck, ini, cctx);
if (ini.get<cfg::debug::session>()){
LOG(LOG_INFO, "Session::end of Session(%u)", sck);
}
shutdown(sck, 2);
close(sck);
}
else {
LOG(LOG_INFO, "Failed to set socket TCP_NODELAY option on client socket");
}
}
