Пример #1
0
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);
}
Пример #2
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);
}
Пример #3
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 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
}
Пример #4
0
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);
}
Пример #5
0
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);
}   
Пример #6
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
}
Пример #7
0
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;
}
Пример #8
0
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;
}
Пример #9
0
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);
     }
Пример #10
0
/**
 * 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;
}
Пример #11
0
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
    }

}
Пример #12
0
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;
}
Пример #13
0
/*---------------------------------------------*/ 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
}
Пример #14
0
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;
}
Пример #15
0
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
}
Пример #16
0
/* 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);
}
Пример #17
0
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
}
Пример #18
0
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);
  }
}
Пример #19
0
/** 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
}
Пример #20
0
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);
}
Пример #21
0
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);
  }
}
Пример #22
0
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
}
Пример #23
0
/* 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;
}
Пример #24
0
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;
}
Пример #25
0
/*
 * 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);
	}
}
Пример #26
0
/*---------------------------------------------*/ 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
}
Пример #27
0
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);
 }
Пример #29
0
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);
}
Пример #30
0
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;
}