int main(int argc, char *argv[]) { SETUP_THE_NUMBERS; TEARDOWN_THE_NUMBERS; char *char_string = string("asdasd"); int c; while ((c = getopt(argc, argv, "hv")) != -1) { switch (c) { case 'h': print_help_message(); prepare_for_exit(); return EXIT_FAILURE; case 'v': print_licence_message(); prepare_for_exit(); return EXIT_FAILURE; } } random_init(); set_signals(); init_windows(); init_modes(); loop(); prepare_for_exit(); free_memory(); return EXIT_SUCCESS; }
int main(int argc, char **argv) { pthread_t threads[NUM_THREADS]; if (argc > 1) { fprintf(stderr, "Usage: %s\n", *argv); exit(1); } /* remember to ignore certain signals */ set_signals(); /* go do it */ for (long i = 0; i < NUM_THREADS; i++) { int rc = pthread_create(&threads[i], NULL, resolver_thread_root, (void *) i); if (rc) { printf("ERROR; return code from pthread_create() is %d\n", rc); exit(-1); } } for (long i = 0; i < NUM_THREADS; i++) { void *retval; pthread_join(threads[i], &retval); } fprintf(stderr, "Resolver exited.\n"); exit(0); }
/* * Apply an ed script by feeding ed itself. */ void do_ed_script(void) { char *t; long beginning_of_this_line; FILE *pipefp = NULL; if (!skip_rest_of_patch) { if (copy_file(filearg[0], TMPOUTNAME) < 0) { unlink(TMPOUTNAME); fatal("can't create temp file %s", TMPOUTNAME); } snprintf(buf, buf_size, "%s%s%s", _PATH_ED, verbose ? " " : " -s ", TMPOUTNAME); pipefp = popen(buf, "w"); } for (;;) { beginning_of_this_line = ftell(pfp); if (pgets(true) == 0) { next_intuit_at(beginning_of_this_line, p_input_line); break; } p_input_line++; for (t = buf; isdigit((unsigned char)*t) || *t == ','; t++) ; /* POSIX defines allowed commands as {a,c,d,i,s} */ if (isdigit((unsigned char)*buf) && (*t == 'a' || *t == 'c' || *t == 'd' || *t == 'i' || *t == 's')) { if (pipefp != NULL) fputs(buf, pipefp); if (*t != 'd') { while (pgets(true)) { p_input_line++; if (pipefp != NULL) fputs(buf, pipefp); if (strEQ(buf, ".\n")) break; } } } else { next_intuit_at(beginning_of_this_line, p_input_line); break; } } if (pipefp == NULL) return; fprintf(pipefp, "w\n"); fprintf(pipefp, "q\n"); fflush(pipefp); pclose(pipefp); ignore_signals(); if (!check_only) { if (move_file(TMPOUTNAME, outname) < 0) { toutkeep = true; chmod(TMPOUTNAME, filemode); } else chmod(outname, filemode); } set_signals(1); }
int run_init_svc(char *cinit_svc) { pid_t pid; /* * leave cinit alone */ pid = fork(); if(pid == -1) { /* err */ print_errno(MSG_ERR_FORK); return 0; } else if(pid == 0) { /* child */ cinit_ipc_sclose(); set_signals(ACT_CLIENT); if(!cinit_ipc_logon()) _exit(1); /* * FIXME: open stderr, stdin, stdout to files / syslog / logable ? * IMPLEMENT PER SERVICE! */ run_svc(cinit_svc); _exit(0); /* nobody cares about us, so exit successfully * anyway */ } /* * parent exits, we don't care about our children */ return 1; }
void sig_handler(ARCH_SIGHDLR_PARAM) { struct sigcontext *sc; int enabled; /* Must be the first thing that this handler does - x86_64 stores * the sigcontext in %rdx, and we need to save it before it has a * chance to get trashed. */ ARCH_GET_SIGCONTEXT(sc, sig); enabled = signals_enabled; if(!enabled && (sig == SIGIO)){ pending |= SIGIO_MASK; return; } block_signals(); CHOOSE_MODE_PROC(sig_handler_common_tt, sig_handler_common_skas, sig, sc); set_signals(enabled); }
void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr, void (*handler)(int)) { unsigned long flags; sigjmp_buf switch_buf, fork_buf; *switch_buf_ptr = &switch_buf; *fork_buf_ptr = &fork_buf; /* Somewhat subtle - siglongjmp restores the signal mask before doing * the longjmp. This means that when jumping from one stack to another * when the target stack has interrupts enabled, an interrupt may occur * on the source stack. This is bad when starting up a process because * it's not supposed to get timer ticks until it has been scheduled. * So, we disable interrupts around the sigsetjmp to ensure that * they can't happen until we get back here where they are safe. */ flags = get_signals(); block_signals(); if(sigsetjmp(fork_buf, 1) == 0) new_thread_proc(stack, handler); remove_sigstack(); set_signals(flags); }
gboolean iteration_func(gpointer data) { mcpanel *panel = data; if (!run_eeg) return FALSE; set_signals(geeg, gexg, gtri, NSAMPLES); mcp_add_samples(panel, 0, NSAMPLES, geeg); mcp_add_samples(panel, 1, NSAMPLES, geeg); mcp_add_samples(panel, 2, NSAMPLES, gexg); mcp_add_triggers(panel, NSAMPLES, gtri); isample += NSAMPLES; if (recording) { recsamples += NSAMPLES; if (recsamples > 201*NSAMPLES) { recording = 0; mcp_notify(panel, REC_PAUSED); } } if ((isample<201*NSAMPLES)&&(isample >= 200*NSAMPLES)) { mcp_popup_message(panel, "Hello!"); isample = 201*NSAMPLES; } return TRUE; }
// A very basic example... // when the user types a character, print it back int main(void) { uint8_t signals[3] = {0, 0, 0}; CPU_PRESCALE(0); // run at 16 MHz pwm_init(); uart_init(BAUD_RATE); set_signals(signals); while (1) { if (uart_available()) { uart_get_pwms(signals); set_signals(signals); } } }
static void restart(int signum) { t_environment *env; (void)signum; env = get_set_environment(NULL); setup_terminal(env); set_signals(&restart); refresh_screen(0); }
int main (int argc, char **argv) { leave_suid(); if ( (program = strrchr(argv[0], '/')) == 0 ) program = argv[0]; else program ++; parse_args(argc, argv); debug("start up"); initlog(program, facility, logfile); debug("init log"); #ifndef NO_FORK if (daemon_mode) { if (daemon(0, 0)) av_shutdown(1); } #endif set_signals(); signal(SIGPIPE, SIG_IGN); if (create_pid_file()) /* bug - don't call shutdown - it removes pidfile */ av_shutdown(1); notice("started"); if ( !no_check && (drweb_ver = dw_getversion()) != -1 ) { notice("drwebd %d.%d found", drweb_ver/100, drweb_ver % 100); } else { no_check = 1; } if ( !no_check && (drweb_id = dw_getid()) != NULL ) { notice("drwebd id = <%s>", drweb_id ); } if ( !no_check ) { dw_getbaseinfo(); } main_loop(); av_shutdown(0); return 0; }
struct tmuxproc * proc_start(const char *name, struct event_base *base, int forkflag, void (*signalcb)(int)) { struct tmuxproc *tp; struct utsname u; #ifdef TMATE_SLAVE if (forkflag) fatal("can't fork"); #else if (forkflag) { switch (fork()) { case -1: fatal("fork failed"); case 0: break; default: return (NULL); } if (daemon(1, 0) != 0) fatal("daemon failed"); clear_signals(0); if (event_reinit(base) != 0) fatalx("event_reinit failed"); } log_open(name); #endif #ifdef HAVE_SETPROCTITLE setproctitle("%s (%s)", name, socket_path); #endif if (uname(&u) < 0) memset(&u, 0, sizeof u); log_debug("%s started (%ld): socket %s, protocol %d", name, (long)getpid(), socket_path, PROTOCOL_VERSION); log_debug("on %s %s %s; libevent %s (%s)", u.sysname, u.release, u.version, event_get_version(), event_get_method()); tp = xcalloc(1, sizeof *tp); tp->name = xstrdup(name); #ifndef TMATE_SLAVE tp->signalcb = signalcb; set_signals(proc_signal_cb, tp); #endif return (tp); }
int main(int argc, char **argv) { set_signals(); getargs(argc, argv); open_files(); reader(); lr0(); lalr(); make_parser(); verbose(); output(); done(0); return 0; }
int main(int argc, char **argv) { t_environment *env; if (argc < 2) ft_putendl_fd_exit("Usage: ft_select [parameters]", 2, 1); env = malloc(sizeof(t_environment)); setup_environment(env, argc, argv); get_set_environment(env); set_signals(&restart); refresh_screen(0); input_loop(); return (0); }
void timer_alarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc) { int enabled; enabled = signals_enabled; if (!signals_enabled) { signals_pending |= SIGALRM_MASK; return; } block_signals(); timer_real_alarm_handler(mc); set_signals(enabled); }
int main (int argc, char *argv[]) { set_signals(); getargs(argc, argv); open_files(); reader(); lr0(); lalr(); make_parser(); verbose(); output(); done(0); /*NOTREACHED*/ }
void alarm_handler(int sig, mcontext_t *mc) { int enabled; enabled = signals_enabled; if (!signals_enabled) { signals_pending |= SIGVTALRM_MASK; return; } block_signals(); real_alarm_handler(mc); set_signals(enabled); }
int main(int argc, char *argv[]) { set_folders(); initialize(); set_signals(); //Iniciar el cliente como servidor de ficheros if (init_client() == -1) error("Error on init client"); while(1) { userin(); procline(); } }
int main(int argc, char **argv) { atexit(cleanup); set_signals(); getargs(argc, argv); open_files(); reader(); lr0(); lalr(); make_parser(); verbose(); output(); exit(0); /*NOTREACHED*/ }
int main(int argc, char *argv[]) { set_signals(); byacc_getargs(argc, argv); open_files(); reader(); lr0(); lalr(); make_parser(); verbose(); output(); done(EXIT_SUCCESS); /*NOTREACHED*/ exit(EXIT_SUCCESS); }
void shell_init() { jobs_head = calloc(1, sizeof(*jobs_head)); on_terminal = (bool) isatty(shell_in); if (on_terminal) { /* input on user terminal? */ set_signals(SIG_IGN, false); /* set shell to ignore most signals */ signal(SIGTSTP, sigtstp_handler); shell_pgid = getpid(); assert(setpgid(shell_pgid, shell_pgid) >= 0); /* make us a process group leader */ tcsetpgrp(shell_in, shell_pgid); /* put stdin on foreground */ tcgetattr(shell_in, &io_flags); /* save terminal mode */ } }
void sig_handler(int sig, mcontext_t *mc) { int enabled; enabled = signals_enabled; if (!enabled && (sig == SIGIO)) { signals_pending |= SIGIO_MASK; return; } block_signals(); sig_handler_common(sig, mc); set_signals(enabled); }
int main(int argc, char **argv) { int o; printf("\nCSF[%d] starting...\n", (int)getpid()); realpath(argv[0], exec_path); if (set_working_dir(exec_path) != 0) { PRINT("Can not set the working directory."); return (2); } set_conf_file(CONF_FILE); while(-1 != (o = getopt(argc, argv, "f:hv"))) { switch(o) { case 'f': set_conf_file(optarg); break; case 'v': output_config(); return 0; case 'h': show_help(); return 0; default: break; } } /* init each modules */ if (csf_init() < 0) { PRINT("CSF init failed. Exited."); return (2); } set_signals(); save_pid(argv[0]); /* starts the server */ server_init(&main_conf); WLOG_ERR("Fatal Error, SERVER DOWN!"); logger_deinit(); PRINT("Fatal Error, SERVER DOWN!"); return (2); }
int main(int argc, char *argv[]) { srand(time(0)); set_signals(); getargs(argc, argv); open_files(); reader(); lr0(); lalr(); make_parser(); graph(); finalize_closure(); verbose(); output(); done(0); /*NOTREACHED */ }
int main(int argc, char **argv) { if (argc > 1) { fprintf(stderr, "Usage: %s\n", *argv); exit(1); } /* remember to ignore certain signals */ set_signals(); /* go do it */ while(do_resolve()); fprintf(stderr, "Resolver exited.\n"); return 0; }
static int make_worker(int slot) { thread_id tid; proc_info *my_info = (proc_info *)malloc(sizeof(proc_info)); /* freed by thread... */ if (my_info == NULL) { ap_log_error(APLOG_MARK, APLOG_ALERT, errno, ap_server_conf, "malloc: out of memory"); clean_child_exit(APEXIT_CHILDFATAL); } my_info->slot = slot; apr_pool_create(&my_info->tpool, pchild); if (slot + 1 > ap_max_child_assigned) ap_max_child_assigned = slot + 1; if (one_process) { set_signals(); ap_scoreboard_image->parent[0].pid = getpid(); return 0; } (void) ap_update_child_status_from_indexes(0, slot, SERVER_STARTING, (request_rec*)NULL); tid = spawn_thread(worker_thread, "apache_worker", B_NORMAL_PRIORITY, my_info); if (tid < B_NO_ERROR) { ap_log_error(APLOG_MARK, APLOG_ERR, errno, NULL, "spawn_thread: Unable to start a new thread"); /* In case system resources are maxxed out, we don't want * Apache running away with the CPU trying to fork over and * over and over again. */ (void) ap_update_child_status_from_indexes(0, slot, SERVER_DEAD, (request_rec*)NULL); sleep(10); free(my_info); return -1; } resume_thread(tid); ap_scoreboard_image->servers[0][slot].tid = tid; return 0; }
int main(int argc, char *argv[]) { #if defined(THINK_C) || defined(__MWERKS__) argc = ccommand(&argv); #endif set_signals(); getargs(argc, argv); open_files(); reader(); lr0(); lalr(); make_parser(); verbose(); output(); done(0); /*NOTREACHED*/ return 0; }
int main( int argc, char *argv[] ) { int connfd; get_config(argc,argv); set_signals(); server_sock = server_start(); cout << "Server start running at port " << server_port << endl; while( true ) { connfd = Accept( server_sock, NULL, NULL ); Request rqst( connfd ); rqst.handle(); } close(server_sock); return 0; }
int main(int ac, char **av) { char *buf; int i; set_signals(); buf = ft_strnew(10); handle_term(0); while (1) { read(0, buf, 10); i = -1; while (buf[++i]) dprintf(1, "%d;", buf[i]); dprintf(1, "\n"); ft_memset(buf, '\0', 10); } return (0); }
void boot_timer_handler(ARCH_SIGHDLR_PARAM) { struct sigcontext *sc; int enabled; ARCH_GET_SIGCONTEXT(sc, sig); enabled = signals_enabled; if(!enabled){ if(sig == SIGVTALRM) pending |= SIGVTALRM_MASK; else pending |= SIGALRM_MASK; return; } block_signals(); do_boot_timer_handler(sc); set_signals(enabled); }
int main(int argc, char*argv[]) /* Purpose: main subroutine Parameters: none Return: result (0=success, nonzero=failure) */ { pthread_t server_status_thread; parse_options(argc, argv); log_it(info, "---------- Monitas (server) by Hugo Rabson ----------"); register_pid(getpid(), "server"); set_signals(true); start_threads_to_watch_ports_for_requests(); pthread_create(&server_status_thread, NULL, generate_server_status_file_regularly, (void*)g->server_status_file); create_and_watch_fifo_for_commands(g->server_comdev); log_it(warn, "Execution should never reach this point"); exit(0); }