Пример #1
0
pk_err_t setup_signal_handlers(void (*caught_handler)(int sig),
			const int *caught_signals, const int *ignored_signals)
{
	int i;

	if (caught_signals != NULL) {
		for (i=0; caught_signals[i] != 0; i++) {
			if (set_signal_handler(caught_signals[i],
						caught_handler)) {
				pk_log(LOG_ERROR, "unable to register signal "
						"handler for signal %d",
						caught_signals[i]);
				return PK_CALLFAIL;
			}
		}
	}
	if (ignored_signals != NULL) {
		for (i=0; ignored_signals[i] != 0; i++) {
			if (set_signal_handler(ignored_signals[i], SIG_IGN)) {
				pk_log(LOG_ERROR, "unable to ignore signal %d",
						ignored_signals[i]);
				return PK_CALLFAIL;
			}
		}
	}
	return PK_SUCCESS;
}
Пример #2
0
void cs_exit(int32_t sig)
{
	if (cs_dump_stack && (sig == SIGSEGV || sig == SIGBUS || sig == SIGQUIT))
		cs_dumpstack(sig);

	set_signal_handler(SIGHUP , 1, SIG_IGN);
	set_signal_handler(SIGPIPE, 1, SIG_IGN);

  struct s_client *cl = cur_client();
  if (!cl)
  	return;

	// this is very important - do not remove
	if (cl->typ != 's') {
		cs_debug_mask(D_TRACE, "thread %8lX ended!", (unsigned long)pthread_self());

		free_client(cl);

		//Restore signals before exiting thread
		set_signal_handler(SIGPIPE , 0, cs_sigpipe);
		set_signal_handler(SIGHUP  , 1, cs_reload_config);

		pthread_exit(NULL);
		return;
	}

	if (!exit_oscam)
	  exit_oscam = sig?sig:1;
}
Пример #3
0
byte *
lizard_decompress_safe(const byte *in, struct lizard_buffer *buf, uns expected_length)
  /* Decompresses in into buf, sets *ptr to the data, and returns the
   * uncompressed length.  If an error has occured, -1 is returned and errno is
   * set.  The buffer buf is automatically reallocated.  SIGSEGV is caught in
   * case of buffer-overflow.  The function is not re-entrant because of a
   * static longjmp handler.  */
{
  uns lock_offset = ALIGN_TO(expected_length + 3, CPU_PAGE_SIZE);	// +3 due to the unaligned access
  if (lock_offset > buf->len)
    lizard_realloc(buf, lock_offset);
  volatile ucw_sighandler_t old_handler = set_signal_handler(SIGSEGV, sigsegv_handler);
  byte *ptr;
  if (!setjmp(safe_decompress_jump))
  {
    ptr = buf->ptr + buf->len - lock_offset;
    int len = lizard_decompress(in, ptr);
    if (len != (int) expected_length)
    {
      ptr = NULL;
      errno = EINVAL;
    }
  }
  else
  {
    msg(L_ERROR, "SIGSEGV caught in lizard_decompress()");
    ptr = NULL;
    errno = EFAULT;
  }
  set_signal_handler(SIGSEGV, old_handler);
  return ptr;
}
Пример #4
0
/* Sets signal handlers to ignore for early startup of OSCam because for example log
   could cause SIGPIPE errors and the normal signal handlers can't be used at this point. */
static void init_signal_pre(void)
{
		set_signal_handler(SIGPIPE , 1, SIG_IGN);
		set_signal_handler(SIGWINCH, 1, SIG_IGN);
		set_signal_handler(SIGALRM , 1, SIG_IGN);
		set_signal_handler(SIGHUP  , 1, SIG_IGN);
}
Пример #5
0
static int set_signal_handlers(void)
{
	if ((set_signal_handler(SIGHUP, signal_handler) == -1)
	     || (set_signal_handler(SIGINT, signal_handler) == -1)
	     || (set_signal_handler(SIGTERM, signal_handler) == -1)
	     || (set_signal_handler(SIGPIPE, SIG_IGN) == -1))
		return -1;
	return 0;
}
Пример #6
0
void
makedaemon(char *logname)
{
  int uid = 32767;
  int gid = 32767;
  char *user = "******";
  struct passwd *pwd;
  int logfd;

  logfd = open(logname, O_WRONLY | O_CREAT | O_APPEND);
  if(logfd < 0) {
    debug(DBG_GLOBAL, 0, "Could not open logfile '%s', exiting", logname);
    exit(255);
  }

  if(getuid() == 0) {
    pwd = getpwnam(user);
    if(pwd) {
      uid = pwd->pw_uid;
      gid = pwd->pw_gid;
    }
    debug(DBG_GLOBAL, 0,
          "Launched as root, trying to become %s (uid %d, gid %d)..",
          user, uid, gid);
    notminus(setgroups(0, (const gid_t *) 0), "setgroups");
    initgroups(user, gid);      // not critical if fails
    notminus(setgid(gid), "setgid");
    notminus(setegid(gid), "setegid");
    notminus(setuid(uid), "setuid");
    notminus(seteuid(gid), "seteuid");
    debug(DBG_GLOBAL, 0, "now forking");
  }


  if(fork() != 0)
    exit(0);

  setsid();
  set_signal_handler(SIGHUP, SIG_IGN);
  set_signal_handler(SIGPIPE, SIG_IGN);

  if(fork() != 0)
    exit(0);

  //chdir("/tmp");
  //chroot("/tmp");
  //umask(077);


  close(0);
  close(1);
  close(2);
  dup2(logfd, 1);
  dup2(logfd, 2);
  debug(DBG_GLOBAL, 0, "Started as a daemon");
}
Пример #7
0
int main(int argc, char **argv) {
	int ret = EXIT_SUCCESS;
	int opt;
	kga_init();
	set_signal_handler(SIGHUP, interrupted);
	set_signal_handler(SIGINT, interrupted);
	set_signal_handler(SIGTERM, interrupted);
	try_scope {
		while ((opt = getopt(argc, argv, "r:d:ti")) != -1) {
			switch(opt) {
			case 'i':
				pkg_confirm = common_confirm;
				break;
			case 'r':
				root = optarg;
				break;
			case 'd':
				db_path = optarg;
				break;
			default:
				throw(pkg_main_incorrect_cmd, 1, "unknown option", NULL);
				break;
			};
		};
		int real_argc = argc - optind;
		char **real_argv = &argv[optind];
		if (!real_argc) {
			throw(pkg_main_incorrect_cmd, 1, "no subcommand", NULL);
		} else if (!strcmp(real_argv[0], "install")) {
			if (real_argc != 2) {
				throw(pkg_main_incorrect_cmd, 1, "incorrect subcommand", NULL);
			};
			pkg_install(real_argv[1], root, db_path, 0, stderr);
		} else if (!strcmp(real_argv[0], "upgrade")) {
			if (real_argc != 2) {
				throw(pkg_main_incorrect_cmd, 1, "incorrect subcommand", NULL);
			};
			pkg_install(real_argv[1], root, db_path, PKG_UPGRADE, stderr);
		} else if (!strcmp(real_argv[0], "drop")) {
			if (real_argc < 2 || real_argc > 3) {
				throw(pkg_main_incorrect_cmd, 1, "incorrect subcommand", NULL);
			};
			char *slash;
			if ((slash = strchr(real_argv[1], '/'))) {
				*slash = '\0';
				pkg_drop(root, db_path, real_argv[1], &slash[1], stderr);
				
			} else {
				pkg_drop(root, db_path, real_argv[1], real_argc == 2 ? NULL : real_argv[2], stderr);
			}
		} else {
			throw(pkg_main_incorrect_cmd, 1, "unknown subcommand", NULL);
		};
	};
	catch {
		if (exception()->type == &pkg_main_incorrect_cmd) {
Пример #8
0
int SMTP_ehlo(int sock, char smtp_mode, const char *host, char *name, char *password, int *opt)
/* send a "EHLO" message to the SMTP listener, return extension status bits */
{
  struct opt *hp;
  char auth_response[511];
  SIGHANDLERTYPE alrmsave;
  const int tmout = (mytimeout >= TIMEOUT_HELO ? mytimeout : TIMEOUT_HELO);

  SockPrintf(sock,"%cHLO %s\r\n", (smtp_mode == 'S') ? 'E' : smtp_mode, host);
  if (outlevel >= O_MONITOR)
      report(stdout, "%cMTP> %cHLO %s\n", 
	    smtp_mode, (smtp_mode == 'S') ? 'E' : smtp_mode, host);

  alrmsave = set_signal_handler(SIGALRM, null_signal_handler);
  set_timeout(tmout);

  *opt = 0;
  while ((SockRead(sock, smtp_response, sizeof(smtp_response)-1)) != -1)
  {
      size_t n;

      set_timeout(0);
      (void)set_signal_handler(SIGALRM, alrmsave);

      n = strlen(smtp_response);
      if (n > 0 && smtp_response[n-1] == '\n')
	  smtp_response[--n] = '\0';
      if (n > 0 && smtp_response[n-1] == '\r')
	  smtp_response[--n] = '\0';
      if (n < 4)
	  return SM_ERROR;
      smtp_response[n] = '\0';
      if (outlevel >= O_MONITOR)
	  report(stdout, "%cMTP< %s\n", smtp_mode, smtp_response);
      for (hp = extensions; hp->name; hp++)
	  if (!strncasecmp(hp->name, smtp_response+4, strlen(hp->name))) {
	      *opt |= hp->value;
	      if (strncmp(hp->name, "AUTH ", 5) == 0)
		strncpy(auth_response, smtp_response, sizeof(auth_response));
		auth_response[sizeof(auth_response)-1] = '\0';
	  }
      if ((smtp_response[0] == '1' || smtp_response[0] == '2' || smtp_response[0] == '3') && smtp_response[3] == ' ') {
	  if (*opt & ESMTP_AUTH)
		SMTP_auth(sock, smtp_mode, name, password, auth_response);
	  return SM_OK;
      }
      else if (smtp_response[3] != '-')
	  return SM_ERROR;

      alrmsave = set_signal_handler(SIGALRM, null_signal_handler);
      set_timeout(tmout);
  }
  return SM_UNRECOVERABLE;
}
Пример #9
0
int
main(int argc, char **argv)
{
    int ret;

    settings_init();

    if (set_signal_handler(signals) == -1) {
        return -1;
    }

    tc_time_init();

    if (read_args(argc, argv) == -1) {
        return -1;
    }

    if (srv_settings.log_path == NULL) {
        srv_settings.log_path = "error_intercept.log";  
    }

    if (tc_log_init(srv_settings.log_path) == -1) {
        return -1;
    }

    ret = tc_event_loop_init(&s_event_loop, MAX_FD_NUM);
    if (ret == TC_EVENT_ERROR) {
        tc_log_info(LOG_ERR, 0, "event loop init failed");
        return -1;
    }

    /* output debug info */
    output_for_debug();
    if (set_details() == -1) {
        return -1;
    }

    if (interception_init(&s_event_loop, srv_settings.binded_ip,
                          srv_settings.port) == TC_ERROR)
    {
        return -1;
    }

    if (set_timer() == -1) {
        return -1;
    }

#if (INTERCEPT_COMBINED)
    tc_event_timer_add(&s_event_loop, CHECK_INTERVAL, interception_push);
#endif
    tc_event_timer_add(&s_event_loop, OUTPUT_INTERVAL,
            interception_output_stat);

    /* run now */
    tc_event_process_cycle(&s_event_loop);

    server_release_resources();

    return 0;
}
Пример #10
0
void StackPrinter::initialize(const char* program_path, time_t startT)
{
  /* store off program path so we can use it later */
  icky_global_program_name = program_path;
  startTime = startT;
  set_signal_handler();
}
Пример #11
0
int
main( int argc, char **argv )
{
    /* Save our program name - for error messages */
	set_DeadPipe_handler(DeadPipe);
    InitMyApp (CLASS_IDENT, argc, argv, NULL, NULL, 0 );
	LinkAfterStepConfig();

    set_signal_handler( SIGSEGV );

    ConnectX( ASDefaultScr, 0 );
    ConnectAfterStep (WINDOW_CONFIG_MASK |
                      WINDOW_NAME_MASK |
                      M_END_WINDOWLIST, 0);
    Config = CreateIdentConfig ();

    /* Request a list of all windows, while we load our config */
    SendInfo ("Send_WindowList", 0);

    LoadBaseConfig ( GetBaseOptions);
	LoadColorScheme();
	LoadConfig ("ident", GetOptions);
    CheckConfigSanity();
	ReloadASDatabase();
	ReloadCategories(True);

	if (MyArgs.src_window == 0)
		MyArgs.src_window = get_target_window();

	/* And at long last our main loop : */
    HandleEvents();
	return 0 ;
}
Пример #12
0
int main(int argc, char **argv) {
    int y, x;
    
    set_signal_handler();

    initscr(); 

    curs_set(0);
    cbreak(); 
    noecho(); 
    keypad(stdscr, TRUE); 
    scrollok(stdscr, TRUE);

    space.wormhole_y = rand() % (LINES - 1) + 1; 
    space.wormhole_x = rand() % (COLS - 1);
    y = rand() % (LINES - 1) + 1;
    x = rand() % (COLS - 1);



    hud.moves = 0;
    store.starcount = 0;
    plot_stars_randomly(); 
    mvprintw(y, x, aircraft.ship); 
    control_ship(y, x);

    refresh();
    endwin(); 

    return(0);
}
Пример #13
0
int init(int argc, char *argv[])
{
  mtn = mtn_init(MODULE_NAME);
  ctx = calloc(1,sizeof(CTX));
  if(!mtn){
    return(-1);
  }
  if(!ctx){
    mtnlogger(NULL, 0, "[error] %s: %s\n", __func__, strerror(errno));
    return(-1);
  }
  mtn->mps_max = 512;
  mtn->logtype = 0;
  mtn->logmode = MTNLOG_STDERR;
  ctx->afd     = -1;
  ctx->nobuf   = 1;
  ctx->text    = 1;
  ctx->delim   = newstr(" ");
  ctx->targets = newarg(0);
  ctx->arg_max = sysconf(_SC_ARG_MAX);
  ctx->cpu_num = sysconf(_SC_NPROCESSORS_ONLN);
  ctx->job_max = sysconf(_SC_NPROCESSORS_ONLN);
  ctx->cmdargs = parse(argc, argv);
  gettimeofday(&(ctx->polltv), NULL);
  if(init_pipe() == -1){
    return(-1);
  }
  if(init_poll() == -1){
    return(-1);
  }
  ctx->job = calloc(ctx->job_max, sizeof(MTNJOB));
  set_signal_handler();
  mtnlogger(mtn, 1, "LogLevel: %d\n", mtn->loglevel);
  return(0);
}
Пример #14
0
/*
 * Fork a child process and then kill the parent so make the calling
 * program a daemon process.
 */
void
makedaemon(void)
{
	if (fork() != 0)
		exit(0);

	setsid();
	set_signal_handler(SIGHUP, SIG_IGN);

	if (fork() != 0)
		exit(0);

	chdir("/");
	umask(0177);

#if NDEBUG
        /*
         * When not in debugging mode, close the standard file
         * descriptors.
         */
	close(0);
	close(1);
	close(2);
#endif
}
Пример #15
0
/*
 *  main
 */
int main(int argc, char *argv[])
{
	int ret;
	char *user;

	progname = argv[0] ? argv[0] : "lttng";

	/* For Mathieu Desnoyers a.k.a. Dr. Tracing */
	user = getenv("USER");
	if (user != NULL && ((strncmp(progname, "drtrace", 7) == 0 ||
				strncmp("compudj", user, 7) == 0))) {
		MSG("%c[%d;%dmWelcome back Dr Tracing!%c[%dm\n", 27,1,33,27,0);
	}
	/* Thanks Mathieu */

	ret = set_signal_handler();
	if (ret < 0) {
		clean_exit(ret);
	}

	ret = parse_args(argc, argv);
	if (ret != 0) {
		clean_exit(ret);
	}

	return 0;
}
Пример #16
0
/* set default values for intercept */
static void settings_init(void)
{
    srv_settings.port = SERVER_PORT;
    srv_settings.hash_size = 65536;
    srv_settings.binded_ip = NULL;

    set_signal_handler();
}
Пример #17
0
/*
 * Fork a child "child" (or in our case a process) and then start up the
 * child_main() function.
 */
static pid_t child_make (struct child_s *ptr)
{
        pid_t pid;

        if ((pid = fork ()) > 0)
                return pid;     /* parent */

        /*
         * Reset the SIGNALS so that the child can be reaped.
         */
        set_signal_handler (SIGCHLD, SIG_DFL);
        set_signal_handler (SIGTERM, SIG_DFL);
        set_signal_handler (SIGHUP, child_sighup_handler);

        child_main (ptr);       /* never returns */
        return -1;
}
Пример #18
0
/* Fork, and have the parent wait for the child to indicate that the parent
   should exit.  In the parent, this returns only on error.  In the child, it
   returns success and sets *status_fd.  If the child writes a byte to the fd,
   the parent will exit with that byte as its exit status.  If the child closes
   the fd without writing anything, the parent will exit(0). */
pk_err_t fork_and_wait(int *status_fd)
{
	int fds[2];
	pid_t pid;
	char ret=1;
	int status;

	/* Make sure the child isn't killed if the parent dies */
	if (set_signal_handler(SIGPIPE, SIG_IGN)) {
		pk_log(LOG_ERROR, "Couldn't block SIGPIPE");
		return PK_CALLFAIL;
	}
	if (pipe(fds)) {
		pk_log(LOG_ERROR, "Can't create pipe");
		return PK_CALLFAIL;
	}

	pid=fork();
	if (pid == -1) {
		pk_log(LOG_ERROR, "fork() failed");
		return PK_CALLFAIL;
	} else if (pid) {
		/* Parent */
		close(fds[1]);
		if (read(fds[0], &ret, sizeof(ret)) == 0) {
			exit(0);
		} else {
			if (waitpid(pid, &status, 0) == -1)
				exit(ret);
			if (WIFEXITED(status))
				exit(WEXITSTATUS(status));
			if (WIFSIGNALED(status)) {
				set_signal_handler(WTERMSIG(status), SIG_DFL);
				raise(WTERMSIG(status));
			}
			exit(ret);
		}
	} else {
		/* Child */
		close(fds[0]);
		*status_fd=fds[1];
	}
	return PK_SUCCESS;
}
Пример #19
0
/*********************************
 * main - this is where it begins
 *********************************/
int main(int argc, char **argv)
{
  std::cout << "********************************************" << std::endl;
  std::cout << "*** cudapts - Nvidia PTS Pool Miner v" << VERSION_MAJOR << "." << VERSION_MINOR << " " << VERSION_EXT << std::endl;
  std::cout << "*** by dga - based on ptsminer." << std::endl;
  std::cout << "*** If you like this software, please consider sending tips to:" << std::endl;
  std::cout << "*** PTS:  Pr8cnhz5eDsUegBZD4VZmGDARcKaozWbBc" << std::endl;
  std::cout << "*** BTC:  17sb5mcCnnt4xH3eEkVi6kHvhzQRjPRBtS" << std::endl;
  std::cout << "*** Your donations will encourage further optimization and development" << std::endl;
  std::cout << "***" << std::endl;
  std::cout << "*** press CTRL+C to exit" << std::endl;
  std::cout << "********************************************" << std::endl;
	
  if (argc < 2 || argc > 4)
    {
      print_help(argv[0]);
      return EXIT_FAILURE;
    }

  t_start = boost::posix_time::second_clock::local_time();
  running = true;

#if defined(__MINGW32__) || defined(__MINGW64__)
  SetConsoleCtrlHandler(ctrl_handler, TRUE);
#elif defined(__GNUG__) && !defined(__APPLE__)
  set_signal_handler(SIGINT, ctrl_handler);
#endif

  const int atexit_res = std::atexit(exit_handler);
  if (atexit_res != 0)
    std::cerr << "atexit registration failed, shutdown will be dirty!" << std::endl;

  // init everything:
  socket_to_server = NULL;
  thread_num_max = 1;
  gpu_device_id = atoi(argv[2]); 
  COLLISION_TABLE_BITS = 21;
  fee_to_pay = 0; //GetArg("-poolfee", 3);
  miner_id = 0; //GetArg("-minerid", 0);
  pool_username = argv[1]; //GetArg("-pooluser", "");
  pool_password = "******"; //GetArg("-poolpassword", "");
	
  if (thread_num_max == 0 || thread_num_max > MAX_THREADS)
    {
      std::cerr << "usage: " << "current maximum supported number of threads = " << MAX_THREADS << std::endl;
      return EXIT_FAILURE;
    }

  // ok, start mining:
  CBlockProviderGW* bprovider = new CBlockProviderGW();
  CMasterThread *mt = new CMasterThread(bprovider);
  mt->run();

  // end:
  return EXIT_SUCCESS;
}
Пример #20
0
/**
 * @author Petr Djakow
 */
void Utils::signalIgnore(const int signum)
{
	#ifdef _GNU_SOURCE
		if(sigignore(signum) == -1)
			FATAL_ERROR(("sigignore(%d)", signum));
		OUT_DEBUG(("Signal '%s' will be ignored", strsignal(signum)));
	#else
		set_signal_handler(signum, SIG_IGN);
		OUT_DEBUG(("Signal '%d' will be ignored", signum));
	#endif
}
Пример #21
0
/**
 * register signal/interrupt handler for signal sig
 *
 * TODO: use appropriate data structure for signal
 *       handlers.
 */
int register_interrupt(int sig, _native_callback_t handler)
{
    DEBUG("register_interrupt\n");

    unsigned state = disableIRQ();

    native_irq_handlers[sig] = handler;
    set_signal_handler(sig, true);

    restoreIRQ(state);

    return 0;
}
Пример #22
0
int set_signal_handlers(void) {
  if (set_signal_handler(SIGPIPE, SIG_IGN) == SIG_ERR) {
    printf("Could not set \"SIGPIPE\" signal.\n");
    return(EX_OSERR);
  }
  if (set_signal_handler(SIGCHLD, SIG_IGN) == SIG_ERR) {
    printf("Could not set \"SIGCHLD\" signal.\n");
    return(EX_OSERR);
  }
  if (set_signal_handler(SIGINT, signal_handler) == SIG_ERR) {
    printf("Could not set \"SIGINT\" signal.\n");
    return(EX_OSERR);
  }
  if (set_signal_handler(SIGHUP, signal_handler) == SIG_ERR) {
    printf("Could not set \"SIGHUP\" signal.\n");
    return(EX_OSERR);
  }
  if (set_signal_handler(SIGTERM, signal_handler) == SIG_ERR) {
    printf("Could not set \"SIGTERM\" signal.\n");
    return(EX_OSERR);
  }
}
Пример #23
0
/**
 * empty signal mask
 */
int unregister_interrupt(int sig)
{
    DEBUG("unregister_interrupt\n");

    unsigned state = disableIRQ();

    set_signal_handler(sig, false);
    native_irq_handlers[sig] = NULL;

    restoreIRQ(state);

    return 0;
}
Пример #24
0
void
initialize_traps ()
{
  register int i;

  trap_list[EXIT_TRAP] = trap_list[DEBUG_TRAP] = (char *)NULL;
  sigmodes[EXIT_TRAP] = sigmodes[DEBUG_TRAP] = SIG_INHERITED;
  original_signals[EXIT_TRAP] = IMPOSSIBLE_TRAP_HANDLER;

  for (i = 1; i < NSIG; i++)
    {
      pending_traps[i] = 0;
      trap_list[i] = (char *)DEFAULT_SIG;
      sigmodes[i] = SIG_INHERITED;
      original_signals[i] = IMPOSSIBLE_TRAP_HANDLER;
    }

  /* Show which signals are treated specially by the shell. */
#if defined (SIGCHLD)
  original_signals[SIGCHLD] =
    (SigHandler *) set_signal_handler (SIGCHLD, SIG_DFL);
  set_signal_handler (SIGCHLD, original_signals[SIGCHLD]);
  sigmodes[SIGCHLD] |= (SIG_SPECIAL | SIG_NO_TRAP);
#endif /* SIGCHLD */

  original_signals[SIGINT] =
    (SigHandler *) set_signal_handler (SIGINT, SIG_DFL);
  set_signal_handler (SIGINT, original_signals[SIGINT]);
  sigmodes[SIGINT] |= SIG_SPECIAL;

#if defined (__BEOS__)
  /* BeOS sets SIGINT to SIG_IGN! */
  original_signals[SIGINT] = SIG_DFL;
#endif

  original_signals[SIGQUIT] =
    (SigHandler *) set_signal_handler (SIGQUIT, SIG_DFL);
  set_signal_handler (SIGQUIT, original_signals[SIGQUIT]);
  sigmodes[SIGQUIT] |= SIG_SPECIAL;

  if (interactive)
    {
      original_signals[SIGTERM] =
	(SigHandler *)set_signal_handler (SIGTERM, SIG_DFL);
      set_signal_handler (SIGTERM, original_signals[SIGTERM]);
      sigmodes[SIGTERM] |= SIG_SPECIAL;
    }
}
Пример #25
0
static void
initialize_shell_signals ()
{
  if (interactive)
    initialize_terminating_signals ();

#if defined (JOB_CONTROL) || defined (HAVE_POSIX_SIGNALS)
  /* All shells use the signal mask they inherit, and pass it along
     to child processes.  Children will never block SIGCHLD, though. */
  sigemptyset (&top_level_mask);
  sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &top_level_mask);
  sigdelset (&top_level_mask, SIGCHLD);
#endif /* JOB_CONTROL || HAVE_POSIX_SIGNALS */

  /* And, some signals that are specifically ignored by the shell. */
  set_signal_handler (SIGQUIT, SIG_IGN);

  if (interactive)
    {
      set_signal_handler (SIGINT, sigint_sighandler);
      set_signal_handler (SIGTERM, SIG_IGN);
    }
}
Пример #26
0
/* set default values for TCPCopy client */
static void
settings_init()
{
    /* init values */
    clt_settings.mtu = DEFAULT_MTU;
    clt_settings.max_rss = MAX_MEMORY_SIZE;
    clt_settings.srv_port = SERVER_PORT;
    clt_settings.percentage = 0;
    clt_settings.session_timeout = DEFAULT_SESSION_TIMEOUT;

    tc_raw_socket_out = TC_INVALID_SOCKET;

    set_signal_handler();
}
Пример #27
0
/*
  このプログラムではスタックアドレスの下半分をハンドリングする。
  
  +-------------------+
  |                  |
  |                  |
  |                  |
  |                  |
  |                  |
  +------------------+
  |                  |
  |                  |
  |                  |
  +------------------+
  | Glibc gurad page |
  +------------------+

 */
int main(int argc, char** argv) 
{

  char*  stackaddr;
  size_t stacksize;
  get_linux_stack_info((void**)&stackaddr, &stacksize);


  /* 代替シグナルスタックのセット */
  start_alternative_stack_addr = stackaddr + SYSTEM_GUARD_PAGE_SIZE;
  end_alternative_stack_addr   = start_alternative_stack_addr + ALT_STACK_SIZE;

  if (mmap(start_alternative_stack_addr, ALT_STACK_SIZE,
           PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) == (void*)-1){
    fprintf(stderr, "faield mmap\n");
    fflush(stderr);
    exit(1);    
  }
  set_alternative_signal_stack(start_alternative_stack_addr, ALT_STACK_SIZE);
  
  /* シグナルハンドラのセット */
  set_signal_handler();

  printf( "Stack region: [%p, %p)\n", stackaddr, stackaddr + stacksize);

  // Linux
  start_new_guard = stackaddr + SYSTEM_GUARD_PAGE_SIZE + ALT_STACK_SIZE;  
  end_new_guard   = stackaddr + (stacksize / 2);

  start_new_guard = (char*)(((intptr_t)start_new_guard + VM_PAGE_SIZE -1) & (~(VM_PAGE_SIZE - 1)));
  end_new_guard   = (char*)(((intptr_t)end_new_guard) & (~(VM_PAGE_SIZE - 1)));


  if (mmap(start_new_guard, end_new_guard - start_new_guard,
           PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) == (void*)-1 ){
    fprintf(stderr, "faield mmap\n");
    fflush(stderr);
    exit(1);    
  }

  printf( "New guard area: [%p, %p)\n", start_new_guard, end_new_guard);


  /* わざとスタックオーバーフローを発生させる */
  cause_stack_overflow();

  return 0;
}
Пример #28
0
void display_init(void)
{
	scr = initscr();
	start_color();
	/* Assign default foreground/background colors to color number -1 */
	use_default_colors();

	init_pair(NO_COLOR,   -1,  -1);
	init_pair(RED_ON_BLACK,     COLOR_RED,  COLOR_BLACK);
	init_pair(BLACK_ON_CYAN,   COLOR_BLACK,  COLOR_CYAN);
	init_pair(BLACK_ON_GREEN,  COLOR_BLACK,  COLOR_GREEN);
	init_pair(BLACK_ON_WHITE,  COLOR_BLACK,  COLOR_WHITE);
	init_pair(BLACK_ON_YELLOW, COLOR_BLACK,  COLOR_YELLOW);
	init_pair(YELLOW_ON_BLACK, COLOR_YELLOW,  COLOR_BLACK);
	init_pair(WHITE_ON_RED,    COLOR_WHITE,  COLOR_RED);
	init_pair(YELLOW_ON_NOTHING,   COLOR_YELLOW,  -1);
	init_pair(GREEN_ON_NOTHING,   COLOR_GREEN,  -1);
	init_pair(RED_ON_NOTHING,   COLOR_RED,  -1);
	init_pair(BLUE_ON_NOTHING,  COLOR_BLUE, -1);
	init_pair(CYAN_ON_NOTHING,  COLOR_CYAN, -1);
	init_pair(MAGENTA_ON_NOTHING,  COLOR_MAGENTA, -1);
	init_pair(WHITE_ON_NOTHING,  COLOR_WHITE, -1);
	/* nodelay(scr, TRUE); */
	noecho();
	curs_set(0);
	/* Create fullscreen log window. When stats are displayed
	   later, it is recreated with appropriate dimensions. */
	win_txt = create_subwindow(0, 0, 0, 0);
	wbkgd(win_txt, COLOR_PAIR(0));

	idlok(win_txt, FALSE);
	/* Get scrolling */
	scrollok(win_txt, TRUE);
	/* Leave cursor where it was */
	leaveok(win_txt, TRUE);

	refresh();

	set_signal_handler();

	max_n_lines = (LINES - 5 - 2 - 3);
	/* core_port_height = max_n_lines < stats_get_n_tasks_tot()? max_n_lines : stats_get_n_tasks_tot(); */

	display_init_screens();
	display_screen(0);
	stats_display_layout(0);
}
Пример #29
0
int main(int argc, char **argv)
{
  char cmdbuf[BUFSIZ];
  int c;

  whoami = argv[0];
  interactive = (isatty(0) && isatty(1));

  while ((c = getopt(argc, argv, "q")) != -1)
    {
      switch (c)
	{
	case 'q':
	  quote_output = 1;
	  break;

	default:
	  fprintf(stderr, "Usage: mrtest [-q]\n");
	  exit (1);
	}
    }

#if defined(__APPLE__) && defined(__MACH__)
  add_error_table(&et_sms_error_table);
  add_error_table(&et_krb_error_table);
#else
  initialize_sms_error_table();
  initialize_krb_error_table();
#endif

#ifdef HAVE_READLINE
  /* we don't want filename completion */
  rl_bind_key('\t', rl_insert);
#endif

  set_signal_handler(SIGINT, discard_input);
  sigsetjmp(jb, 1);

  while (!quit)
    {
      if (!mr_gets("moira:  ", cmdbuf, BUFSIZ))
	break;
      execute_line(cmdbuf);
    }
  mr_disconnect();
  exit(0);
}
Пример #30
0
/*
 *  main
 */
int main(int argc, char *argv[])
{
	int ret;

	progname = argv[0] ? argv[0] : "lttng";

	ret = set_signal_handler();
	if (ret < 0) {
		clean_exit(ret);
	}

	ret = parse_args(argc, argv);
	if (ret != 0) {
		clean_exit(ret);
	}

	return 0;
}