int main (int argc, char *argv[]){ sigset_t allsignals; sigemptyset(&allsignals); sigaddset(&allsignals, SIGUSR1); //sigprocmask(SIG_UNBLOCK, &usr1set, NULL); sigfillset(&allsignals); sigprocmask(SIG_BLOCK, &allsignals, NULL); fflush(stdout); siginterrupt(SIGUSR1,0); struct sigaction action, oldaction; action.sa_handler=entradadatos; action.sa_mask=allsignals; action.sa_flags=SA_RESTART; sigaction (SIGUSR1,&action, NULL); siginterrupt(SIGUSR1,0); //(void) signal(SIGUSR1,entradadatos); printf("Name sacoboxeo\n"); printf("Colour F0F0F0 0F0F0F\n"); printf("RobotOption %i 1\n",USE_NON_BLOCKING); printf("RobotOption %i %i\n",SIGNAL,SIGUSR1); sigprocmask(SIG_UNBLOCK, &allsignals, NULL); while(1){ fflush(stdout); } return(0); }
/* * do the "paper work" * - save my own pid in /var/run/$0.{port#}.pid */ static void okay(int pn) { int fd; char *p, numbuf[80]; if (pidfile[0] == '\0') { p = rindex(prog, '/'); p = (p == NULL) ? prog : p + 1; snprintf(pidfile, sizeof pidfile, "%s%s.%d.pid", _PATH_VARRUN, p, pn); } fd = open(pidfile, O_WRONLY|O_CREAT|O_EXCL, 0644); if (fd < 0) { perror(pidfile); exit(21); } siginterrupt(SIGTERM, 1); siginterrupt(SIGHUP, 1); signal(SIGTERM, quit); signal(SIGHUP, quit); signal(SIGINT, quit); snprintf(numbuf, sizeof numbuf, "%d\n", getpid()); if (write(fd, numbuf, strlen(numbuf)) < 0) { perror(pidfile); quit(23); } (void) close(fd); }
static void install_signal_handlers(void) { #ifdef SIGHUP /* ignore SIGHUP signal */ if((old_sighup_handler = signal(SIGHUP, SIG_IGN)) == SIG_ERR) logmsg("cannot install SIGHUP handler: %s", strerror(ERRNO)); #endif #ifdef SIGPIPE /* ignore SIGPIPE signal */ if((old_sigpipe_handler = signal(SIGPIPE, SIG_IGN)) == SIG_ERR) logmsg("cannot install SIGPIPE handler: %s", strerror(ERRNO)); #endif #ifdef SIGALRM /* ignore SIGALRM signal */ if((old_sigalrm_handler = signal(SIGALRM, SIG_IGN)) == SIG_ERR) logmsg("cannot install SIGALRM handler: %s", strerror(ERRNO)); #endif #ifdef SIGINT /* handle SIGINT signal with our exit_signal_handler */ if((old_sigint_handler = signal(SIGINT, exit_signal_handler)) == SIG_ERR) logmsg("cannot install SIGINT handler: %s", strerror(ERRNO)); else siginterrupt(SIGINT, 1); #endif #ifdef SIGTERM /* handle SIGTERM signal with our exit_signal_handler */ if((old_sigterm_handler = signal(SIGTERM, exit_signal_handler)) == SIG_ERR) logmsg("cannot install SIGTERM handler: %s", strerror(ERRNO)); else siginterrupt(SIGTERM, 1); #endif }
void gotsignal(int signum) { char msg[100]; switch(signum) { case SIGUSR1: // kill -s USR1 pid signal(SIGUSR1, gotsignal); siginterrupt(SIGUSR1, 0); sprintf(msg, "got SIGUSR1 signal:%d\n", signum); break; case SIGINT: signal(SIGINT, gotsignal); siginterrupt(SIGINT, 0); sprintf(msg, "got SIGINT signal, quitting...:%d\n", signum); quit=signum; break; case SIGQUIT: signal(SIGQUIT, gotsignal); siginterrupt(SIGQUIT, 0); sprintf(msg, "got SIGQUIT signal, quitting...:%d\n", signum); quit=signum; break; case SIGBUS: //vmeish(); not to be called (if called, it kills dims process) sprintf(msg, "got SIGBUS signal:%d\n", signum); break; default: sprintf(msg, "got unknown signal:%d\n", signum); }; prtLog(msg); }
int main(int argc, char **argv) { infolog_SetFacility((char *)"CTP"); infolog_SetStream("",0); setlinebuf(stdout); signal(SIGUSR1, gotsignal); siginterrupt(SIGUSR1, 0); signal(SIGQUIT, gotsignal); siginterrupt(SIGQUIT, 0); signal(SIGBUS, gotsignal); siginterrupt(SIGBUS, 0); micrate(-1); if(micratepresent()) { SLOT_S= 30; // was 60 before 10.11.2011 } else { SLOT_S= 5; // in lab just 5secs }; /* if(envcmp("VMESITE", "ALICE")==0) { udpsock= udpopens("alidcscom835", send2PORT); } else { udpsock= udpopens("avmes", send2PORT); }; */ ds_register(); while(1) { int rc=0; rc= update_qpll(); if(rc!=0) break; //printf("sleteping 10secs...\n"); fflush(stdout); //sleep(1) ; //msleep(1000); dtq_sleep(2); //printf("slept 10secs...\n"); fflush(stdout); }; ds_stop(); exit(0); }
static void install_signal_handlers(void) { #ifdef SIGHUP /* ignore SIGHUP signal */ if((old_sighup_handler = signal(SIGHUP, SIG_IGN)) == SIG_ERR) logmsg("cannot install SIGHUP handler: %s", strerror(errno)); #endif #ifdef SIGPIPE /* ignore SIGPIPE signal */ if((old_sigpipe_handler = signal(SIGPIPE, SIG_IGN)) == SIG_ERR) logmsg("cannot install SIGPIPE handler: %s", strerror(errno)); #endif #ifdef SIGINT /* handle SIGINT signal with our exit_signal_handler */ if((old_sigint_handler = signal(SIGINT, exit_signal_handler)) == SIG_ERR) logmsg("cannot install SIGINT handler: %s", strerror(errno)); else siginterrupt(SIGINT, 1); #endif #ifdef SIGTERM /* handle SIGTERM signal with our exit_signal_handler */ if((old_sigterm_handler = signal(SIGTERM, exit_signal_handler)) == SIG_ERR) logmsg("cannot install SIGTERM handler: %s", strerror(errno)); else siginterrupt(SIGTERM, 1); #endif #if defined(SIGBREAK) && defined(WIN32) /* handle SIGBREAK signal with our exit_signal_handler */ if((old_sigbreak_handler = signal(SIGBREAK, exit_signal_handler)) == SIG_ERR) logmsg("cannot install SIGBREAK handler: %s", strerror(errno)); else siginterrupt(SIGBREAK, 1); #endif }
test_code_t test_bye (gnutls_session_t session) { int ret; char data[20]; int secs = 6; #ifndef _WIN32 int old; signal (SIGALRM, got_alarm); #endif sprintf (prio_str, INIT_STR ALL_CIPHERS ":" ALL_COMP ":" ALL_CERTTYPES ":%s:" ALL_MACS ":" ALL_KX ":%s", protocol_str, rest); _gnutls_priority_set_direct (session, prio_str); gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); ret = do_handshake (session); if (ret == TEST_FAILED) return ret; ret = gnutls_bye (session, GNUTLS_SHUT_WR); if (ret < 0) return TEST_FAILED; #ifndef _WIN32 old = siginterrupt (SIGALRM, 1); alarm (secs); #else setsockopt ((int) gnutls_transport_get_ptr (session), SOL_SOCKET, SO_RCVTIMEO, (char *) &secs, sizeof (int)); #endif do { ret = gnutls_record_recv (session, data, sizeof (data)); } while (ret > 0); #ifndef _WIN32 siginterrupt (SIGALRM, old); #else if (WSAGetLastError () == WSAETIMEDOUT || WSAGetLastError () == WSAECONNABORTED) alrm = 1; #endif if (ret == 0) return TEST_SUCCEED; if (alrm == 0) return TEST_UNSURE; return TEST_FAILED; }
test_code_t test_bye (gnutls_session session) { int ret; char data[20]; int old, secs = 6; #ifndef _WIN32 signal (SIGALRM, got_alarm); #endif ADD_ALL_CIPHERS (session); ADD_ALL_COMP (session); ADD_ALL_CERTTYPES (session); ADD_ALL_PROTOCOLS (session); ADD_ALL_MACS (session); ADD_ALL_KX (session); gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, xcred); ret = do_handshake (session); if (ret == TEST_FAILED) return ret; ret = gnutls_bye (session, GNUTLS_SHUT_WR); if (ret < 0) return TEST_FAILED; #ifndef _WIN32 old = siginterrupt (SIGALRM, 1); alarm (secs); #else setsockopt (gnutls_transport_get_ptr (session), SOL_SOCKET, SO_RCVTIMEO, (char *) &secs, sizeof (int)); #endif do { ret = gnutls_record_recv (session, data, sizeof (data)); } while (ret > 0); #ifndef _WIN32 siginterrupt (SIGALRM, old); #else if (WSAGetLastError () == WSAETIMEDOUT || WSAGetLastError () == WSAECONNABORTED) alrm = 1; #endif if (ret == 0) return TEST_SUCCEED; if (alrm == 0) return TEST_UNSURE; return TEST_FAILED; }
int voice_install_signal_handler(void) { lprintf(L_NOISE, "%s: Installing signal handlers", program_name); if (signals_initialized) { lprintf(L_NOISE, "%s: Signal handlers are already installed", program_name); return(OK); }; old_sigalrm = signal(SIGALRM, signal_sigalrm); old_sigchld = signal(SIGCHLD, signal_sigchld); old_sighup = signal(SIGHUP, signal_sighup); old_sigint = signal(SIGINT, signal_sigint); old_sigpipe = signal(SIGPIPE, signal_sigpipe); old_sigquit = signal(SIGQUIT, signal_sigquit); old_sigterm = signal(SIGTERM, signal_sigterm); old_sigusr1 = signal(SIGUSR1, signal_sigusr1); old_sigusr2 = signal(SIGUSR2, signal_sigusr2); #ifdef HAVE_SIGINTERRUPT siginterrupt(SIGALRM, TRUE); siginterrupt(SIGCHLD, TRUE); siginterrupt(SIGHUP, TRUE); siginterrupt(SIGINT, TRUE); siginterrupt(SIGPIPE, TRUE); siginterrupt(SIGQUIT, TRUE); siginterrupt(SIGTERM, TRUE); siginterrupt(SIGUSR1, TRUE); siginterrupt(SIGUSR2, TRUE); #endif alarm(cvd.watchdog_timeout.d.i); signals_initialized = TRUE; return(OK); }
/** * Listen on listener socket * */ static int listen_for_hijackers ( struct hijack_listener *listener, const char *interface ) { int fd; pid_t child; int rc; logmsg ( LOG_INFO, "Listening on %s\n", listener->sun.sun_path ); while ( ! signalled ) { /* Accept new connection, interruptibly */ siginterrupt ( SIGINT, 1 ); siginterrupt ( SIGHUP, 1 ); fd = accept ( listener->fd, NULL, 0 ); siginterrupt ( SIGINT, 0 ); siginterrupt ( SIGHUP, 0 ); if ( fd < 0 ) { if ( errno == EINTR ) { continue; } else { logmsg ( LOG_ERR, "accept failed: %s\n", strerror ( errno ) ); goto err; } } /* Fork child process */ child = fork(); if ( child < 0 ) { logmsg ( LOG_ERR, "fork failed: %s\n", strerror ( errno ) ); goto err; } if ( child == 0 ) { /* I am the child; run the hijacker */ rc = run_hijacker ( interface, fd ); close ( fd ); exit ( rc ); } close ( fd ); } logmsg ( LOG_INFO, "Stopped listening on %s\n", listener->sun.sun_path ); return 0; err: if ( fd >= 0 ) close ( fd ); return -1; }
void check_signal() /* check if a signal has been received and handle it */ { /* we reinstall the signal handler functions here and not directly in the handlers, * as it is not supported on some systems (HP-UX) and makes fcron crash */ if (sig_chld > 0) { wait_chld(); sig_chld = 0; #ifdef HAVE_SIGNAL (void)signal(SIGCHLD, sigchild_handler); siginterrupt(SIGCHLD, 0); #endif } if (sig_conf > 0) { if (sig_conf == 1) { /* update configuration */ synchronize_dir(".", 0); sig_conf = 0; #ifdef HAVE_SIGNAL signal(SIGHUP, sighup_handler); siginterrupt(SIGHUP, 0); #endif } else { /* reload all configuration */ reload_all("."); sig_conf = 0; #ifdef HAVE_SIGNAL signal(SIGUSR1, sigusr1_handler); siginterrupt(SIGUSR1, 0); #endif } } if (sig_debug > 0) { print_schedule(); debug_opt = (debug_opt > 0) ? 0 : 1; explain("debug_opt = %d", debug_opt); sig_debug = 0; #ifdef HAVE_SIGNAL signal(SIGUSR2, sigusr2_handler); siginterrupt(SIGUSR2, 0); #endif } }
int get_con(char* servername, int port) { struct hostent *h2; struct sockaddr_in sin; inrp_by_user = YEA; show_message("½¨Á¢Á¬ÏßÖÐ (Ctrl-C ÖжÏ) ..."); if ((h2 = gethostbyname(servername)) == NULL) sin.sin_addr.s_addr = inet_addr(servername); else memcpy(&sin.sin_addr.s_addr, h2->h_addr, h2->h_length); sin.sin_family = AF_INET; if (!(a = socket(AF_INET, SOCK_STREAM, 0))) return -1; sin.sin_port = htons(port); signal(SIGALRM, (void *) interrupt_chk); siginterrupt(SIGINT, 1); alarm(1); if ((connect(a, (struct sockaddr *) & sin, sizeof(sin)))) { signal(SIGALRM, SIG_IGN); return -1; } signal(SIGALRM, SIG_IGN); inrp_by_user = NA; write(0, " ", 1); show_message(NULL); return 1; }
/*---------------------------------------------*/ void gotsignal(int signum) { char msg[100]; // SIGUSR1: // kill -s USR1 pid signal(signum, gotsignal); siginterrupt(signum, 0); sprintf(msg, "got signal:%d", signum); prtLog(msg); if((signum==SIGUSR1) || (signum==SIGQUIT) ) { int np; np= getNAllPartitions(); if(np!=0) { //quit=1; // wait till all partitions stopped //sprintf(msg, "Waiting for the stop of all partitions before exit"); sprintf(msg, "Unsuccessful attempt to stop ctpproxy, %d partitions active", np); prtLog(msg); pq_send(mq_sendmsg,"quitignored"); } else { quit=10; // stop immediately (no partitions loaded) }; } else if((signum==SIGKILL) || (signum==SIGINT) ) { sprintf(msg, "SIGINT, immediate stop"); prtLog(msg); quit=11; // =9. stop immediately }; #ifdef PQWAY if(quit>9) { pq_send(mq_sendmsg,"quit"); }; #endif }
bool NamedPipe::openInternal (const String& pipeName, const bool createPipe) { close(); NamedPipeInternal* const intern = new NamedPipeInternal(); internal = intern; intern->createdPipe = createPipe; intern->blocked = false; intern->stopReadOperation = false; signal (SIGPIPE, NamedPipeInternal::signalHandler); siginterrupt (SIGPIPE, 1); const String pipePath ("/tmp/" + File::createLegalFileName (pipeName)); intern->pipeInName = pipePath + "_in"; intern->pipeOutName = pipePath + "_out"; intern->pipeIn = -1; intern->pipeOut = -1; if (createPipe) { if ((mkfifo (intern->pipeInName.toUTF8(), 0666) && errno != EEXIST) || (mkfifo (intern->pipeOutName.toUTF8(), 0666) && errno != EEXIST)) { delete intern; internal = 0; return false; } } return true; }
void MR_signal_should_restart(int sig, MR_bool restart) { #if defined(MR_HAVE_SIGACTION) struct sigaction act; if (sigaction(sig, NULL, &act) != 0) { MR_perror("error setting signal system call behaviour"); exit(1); } if (restart) { act.sa_flags |= SA_RESTART; } else { act.sa_flags &= ~SA_RESTART; } if (sigaction(sig, &act, NULL) != 0) { MR_perror("error setting signal system call behaviour"); exit(1); } #elif defined(MR_HAVE_SIGINTERRUPT) if (siginterrupt(sig, !restart) != 0) { MR_perror("error setting signal system call behaviour"); exit(1); } #endif }
/* wrapper to hide signal interface differrencies */ int joe_set_signal(int signum, sighandler_t handler) { int retval; #ifdef HAVE_SIGACTION struct sigaction sact; memset(&sact, 0, sizeof(sact)); sact.sa_handler = handler; #ifdef SA_INTERRUPT sact.sa_flags = SA_INTERRUPT; #endif retval = sigaction(signum, &sact, NULL); #elif defined(HAVE_SIGVEC) struct sigvec svec; memset(&svec, 0, sizeof(svec)); svec.sv_handler = handler; #ifdef HAVE_SV_INTERRUPT svec.sv_flags = SV_INTERRUPT; #endif retval = sigvec(signum, &svec, NULL); #else retval = (signal(signum, handler) != SIG_ERR) ? 0 : -1; #ifdef HAVE_SIGINTERRUPT siginterrupt(signum, 1); #endif #endif return(retval); }
static void sig_install_timer(void) { #if !OS_TIMER signal(SIGALRM, sig_handle_timer); sig_timer_emu_init(TIMER_INTERVAL * clk_tck); #else struct sigaction sa; struct itimerval it; memset(&sa, 0, sizeof(sa)); sa.sa_handler = sig_handle_timer; #ifdef SA_RESTART sa.sa_flags = SA_RESTART; #endif sigaction(SIGALRM, &sa, NULL); #if !defined(SA_RESTART) && !defined(__DJGPP__) siginterrupt(SIGALRM, 0); #endif it.it_value.tv_sec = TIMER_INTERVAL; it.it_value.tv_usec = 0; #if defined(SA_RESTART) || defined(__DJGPP__) it.it_interval = it.it_value; #else memset(&it.it_interval, 0, sizeof(it.it_interval)); #endif if (setitimer(ITIMER_REAL, &it, NULL)) pexit("setitimer"); #endif }
static RETSIGTYPE sig_alarm(int signo) { struct sigaction act; act.sa_handler = sig_alarm; sigemptyset(&act.sa_mask); act.sa_flags = 0; #ifdef SA_INTERRUPT act.sa_flags |= SA_INTERRUPT; #endif /* Install this handler for SIGALRM. */ if (sigaction(SIGALRM, &act, NULL) < 0) { pr_log_pri(PR_LOG_WARNING, "unable to install SIGALRM handler via sigaction(2): %s", strerror(errno)); } #ifdef HAVE_SIGINTERRUPT if (siginterrupt(SIGALRM, 1) < 0) { pr_log_pri(PR_LOG_WARNING, "unable to allow SIGALRM to interrupt system calls: %s", strerror(errno)); } #endif recvd_signal_flags |= RECEIVED_SIG_ALRM; nalarms++; /* Reset the alarm */ _total_time += _current_timeout; if (_current_timeout) { _alarmed_time = time(NULL); alarm(_current_timeout); } }
/** Register all necessary signal handlers. */ void setup_signals(void) { struct sigaction act; act.sa_handler = SIG_IGN; act.sa_flags = 0; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask, SIGPIPE); sigaddset(&act.sa_mask, SIGALRM); #ifdef SIGWINCH sigaddset(&act.sa_mask, SIGWINCH); sigaction(SIGWINCH, &act, 0); #endif sigaction(SIGPIPE, &act, 0); act.sa_handler = sigalrm_handler; sigaction(SIGALRM, &act, 0); signal_add(&sig_hup, sighup_callback, 0, SIGHUP); signal_add(&sig_int, sigint_callback, 0, SIGINT); signal_add(&sig_term, sigterm_callback, 0, SIGTERM); signal_add(&sig_chld, sigchld_callback, 0, SIGCHLD); #ifdef HAVE_RESTARTABLE_SYSCALLS /* * At least on Apollo sr10.1 it seems continuing system calls * after signal is the default. The following 'siginterrupt' * should change that default to interrupting calls. */ siginterrupt(SIGALRM, 1); #endif }
static void signal_handler(int sig_num) { #ifdef WITH_THREAD #ifdef WITH_PTH if (PyThread_get_thread_ident() != main_thread) { pth_raise(*(pth_t *) main_thread, sig_num); return; } #endif /* See NOTES section above */ if (getpid() == main_pid) { #endif is_tripped++; Handlers[sig_num].tripped = 1; Py_AddPendingCall(checksignals_witharg, NULL); #ifdef WITH_THREAD } #endif #ifdef SIGCHLD if (sig_num == SIGCHLD) { /* To avoid infinite recursion, this signal remains reset until explicit re-instated. Don't clear the 'func' field as it is our pointer to the Python handler... */ return; } #endif #ifdef HAVE_SIGINTERRUPT siginterrupt(sig_num, 1); #endif PyOS_setsig(sig_num, signal_handler); }
int main (int argc, char *argv[]) { char c; printf("Tapez return en moins de 5 secondes ! \n"); fflush(stdout); if(signal(SIGALRM,sig_handler)==SIG_ERR) { perror("signal"); exit(EXIT_FAILURE); } // sigalrm interrompt les appels système if(siginterrupt(SIGALRM,true)<0) { perror("siginterrupt"); exit(EXIT_FAILURE); } int r=0; alarm(5); if(!expired) { r=read(STDIN_FILENO,&c,1); } else { // sig_handler a déjà été exécuté // le délai a déjà expiré, inutile de faire read } alarm(0); // arrêt du timer if((r==1)&&(c=='\n')) { printf("Gagné \n"); exit(EXIT_SUCCESS); } else { printf("Perdu !\n"); exit(EXIT_FAILURE); } }
static void setup_signals() { #ifdef POSIX_SIGNALS struct sigaction act; act.sa_handler = SIG_IGN; act.sa_flags = 0; (void) sigemptyset(&act.sa_mask); (void) sigaddset(&act.sa_mask, SIGPIPE); (void) sigaddset(&act.sa_mask, SIGALRM); # ifdef SIGWINCH (void) sigaddset(&act.sa_mask, SIGWINCH); (void) sigaction(SIGWINCH, &act, NULL); # endif (void) sigaction(SIGPIPE, &act, NULL); act.sa_handler = dummy; (void) sigaction(SIGALRM, &act, NULL); act.sa_handler = s_rehash; (void) sigemptyset(&act.sa_mask); (void) sigaddset(&act.sa_mask, SIGHUP); (void) sigaction(SIGHUP, &act, NULL); act.sa_handler = s_restart; (void) sigaddset(&act.sa_mask, SIGINT); (void) sigaction(SIGINT, &act, NULL); (void) sigaddset(&act.sa_mask, SIGUSR2); (void) sigaction(SIGUSR2, &act, NULL); act.sa_handler = s_die; (void) sigaddset(&act.sa_mask, SIGTERM); (void) sigaction(SIGTERM, &act, NULL); #else # ifndef HAVE_RELIABLE_SIGNALS (void) signal(SIGPIPE, dummy); # ifdef SIGWINCH (void) signal(SIGWINCH, dummy); # endif # else # ifdef SIGWINCH (void) signal(SIGWINCH, SIG_IGN); # endif (void) signal(SIGPIPE, SIG_IGN); # endif (void) signal(SIGALRM, dummy); (void) signal(SIGHUP, s_rehash); (void) signal(SIGTERM, s_die); (void) signal(SIGINT, s_restart); (void) signal(SIGUSR2, s_restart); #endif #ifdef RESTARTING_SYSTEMCALLS /* * * At least on Apollo sr10.1 it seems continuing system calls * after signal is the default. The following 'siginterrupt' * should change that default to interrupting calls. */ (void) siginterrupt(SIGALRM, 1); #endif }
/* send a prompt, and use the system for internal buffering. Speed is not of the essence here !!! */ static int ConsoleGetc(int sno) { CACHE_REGS register StreamDesc *s = &GLOBAL_Stream[sno]; int ch; restart: /* keep the prompt around, just in case, but don't actually show it in silent mode */ if (LOCAL_newline) { if (!silentMode()) { char *cptr = LOCAL_Prompt, ch; /* use the default routine */ while ((ch = *cptr++) != '\0') { GLOBAL_Stream[StdErrStream].stream_putc(StdErrStream, ch); } } strncpy(LOCAL_Prompt, (char *)RepAtom(LOCAL_AtPrompt)->StrOfAE, MAX_PROMPT); LOCAL_newline = FALSE; } #if HAVE_SIGINTERRUPT siginterrupt(SIGINT, TRUE); #endif LOCAL_PrologMode |= ConsoleGetcMode; ch = fgetc(s->file); printf("got %d\n", ch); #if HAVE_SIGINTERRUPT siginterrupt(SIGINT, FALSE); #endif if (LOCAL_PrologMode & InterruptMode) { Yap_external_signal(0, YAP_INT_SIGNAL); LOCAL_PrologMode &= ~ConsoleGetcMode; LOCAL_newline = TRUE; if (LOCAL_PrologMode & AbortMode) { Yap_Error(ABORT_EVENT, TermNil, ""); LOCAL_ErrorMessage = "Abort"; return EOF; } goto restart; } else { LOCAL_PrologMode &= ~ConsoleGetcMode; } if (ch == EOF) return EOF; return ch; }
gboolean mainloop_add_signal(int sig, void (*dispatch) (int sig)) { GSource *source = NULL; int priority = G_PRIORITY_HIGH - 1; if (sig == SIGTERM) { /* TERM is higher priority than other signals, * signals are higher priority than other ipc. * Yes, minus: smaller is "higher" */ priority--; } if (sig >= NSIG || sig < 0) { crm_err("Signal %d is out of range", sig); return FALSE; } else if (crm_signals[sig] != NULL && crm_signals[sig]->handler == dispatch) { crm_trace("Signal handler for %d is already installed", sig); return TRUE; } else if (crm_signals[sig] != NULL) { crm_err("Different signal handler for %d is already installed", sig); return FALSE; } CRM_ASSERT(sizeof(crm_signal_t) > sizeof(GSource)); source = g_source_new(&crm_signal_funcs, sizeof(crm_signal_t)); crm_signals[sig] = (crm_signal_t *) mainloop_setup_trigger(source, priority, NULL, NULL); CRM_ASSERT(crm_signals[sig] != NULL); crm_signals[sig]->handler = dispatch; crm_signals[sig]->signal = sig; if (crm_signal(sig, mainloop_signal_handler) == FALSE) { crm_signal_t *tmp = crm_signals[sig]; crm_signals[sig] = NULL; mainloop_destroy_trigger((crm_trigger_t *) tmp); return FALSE; } #if 0 /* If we want signals to interrupt mainloop's poll(), instead of waiting for * the timeout, then we should call siginterrupt() below * * For now, just enforce a low timeout */ if (siginterrupt(sig, 1) < 0) { crm_perror(LOG_INFO, "Could not enable system call interruptions for signal %d", sig); } #endif return TRUE; }
/* * Command parser. */ static void cmdscanner(void) { struct cmd *c; for (;;) { if (gotintr) { putchar('\n'); gotintr = 0; } if (fromatty) { printf("lpc> "); fflush(stdout); } siginterrupt(SIGINT, 1); if (fgets(cmdline, MAX_CMDLINE, stdin) == NULL) { if (errno == EINTR && gotintr) { siginterrupt(SIGINT, 0); return; } siginterrupt(SIGINT, 0); quit(0, NULL); } siginterrupt(SIGINT, 0); makeargv(); if (margc == 0) break; c = getcmd(margv[0]); if (c == (struct cmd *)-1) { printf("?Ambiguous command\n"); continue; } if (c == 0) { printf("?Invalid command\n"); continue; } if (c->c_priv && getuid() && ingroup(LPR_OPER) == 0) { printf("?Privileged command\n"); continue; } (*c->c_handler)(margc, margv); } }
/*---------------------------------------------*/ void gotsignal(int signum) { char msg[100]; // SIGUSR1: // kill -s USR1 pid signal(signum, gotsignal); siginterrupt(signum, 0); sprintf(msg, "got signal:%d", signum); prtLog(msg); if((signum==SIGUSR1) || (signum==SIGKILL) ) { quit=1; };quit=signum; // for ANY signal }
int main(int argc, char **argv) { signal(SIGINT, handle_interrupt); siginterrupt(SIGINT,1); //Call read in loop slush(); return EXIT_SUCCESS; }
Pimpl (const String& pipePath, bool createPipe) : pipeInName (pipePath + "_in"), pipeOutName (pipePath + "_out"), pipeIn (-1), pipeOut (-1), createdPipe (createPipe), blocked (false), stopReadOperation (false) { signal (SIGPIPE, signalHandler); siginterrupt (SIGPIPE, 1); }
static void InitiateShutdown (int sig) { /* * Start timer to allow kernel gracefully * shutdown existing connections when system * is shut down. */ siginterrupt(SIGALRM, 1); signal (SIGALRM, Shutdown); alarm (10); }
int main (int argc, char *argv[]) { canHandle h; int channel; int bitrate = BAUD_1M; errno = 0; if (argc != 3 || (channel = 0, errno) != 0) { printf("usage %s address byte1\n", argv[0]); exit(1); } else { printf("Sending a message on channel %d\n", channel); } /* Allow signals to interrupt syscalls(e.g in canReadBlock) */ siginterrupt(SIGINT, 1); /* Open channel, set parameters and go on bus */ //h = canOpenChannel(channel, canOPEN_EXCLUSIVE | canOPEN_REQUIRE_EXTENDED); h = canOpenChannel(channel, canOPEN_EXCLUSIVE); if (h < 0) { printf("canOpenChannel %d failed\n", channel); return -1; } canBusOff(h); check("canSetBusParams", canSetBusParams(h, bitrate, 4, 3, 2, 1, 0)); // Work-around for Leaf bug check("canSetBusOutputControl", canSetBusOutputControl(h, canDRIVER_NORMAL)); check("canBusOn", canBusOn(h)); //OY 8/20/2014 //unsigned char channel = atoi(argv[2])); msg[0] = 0; msg[2] = 1; msg[3] = 41; if (atoi(argv[2]) == 0) msg[1] = 1; if (atoi(argv[2]) == 100) msg[1] = 2; check("canWrite", canWrite(h, atoi(argv[1]), msg, 4, 0)); //printf("%d %d %d %d %d\n",msg[0], msg[1], msg[2], msg[3], channel); check("canWriteSync", canWriteSync(h, 1000)); //check("canBusOff", canBusOff(h)); check("canClose", canClose(h)); return 0; }