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);
}
