int main(int argc,char **argv)
{
mutil_thread = 0;
setup_signal_handler();
init_clients();
InitNetSystem();
ENGINE engine = CreateEngine();
int csize = atoi(argv[3]);
int i = 0;
for(; i < csize; ++i)
EConnect(engine,argv[1],atoi(argv[2]),(void*)engine,on_connect,1000);
uint32_t tick,now;
tick = now = GetSystemMs();
while(!stop) {
EngineRun(engine,50);
sendpacket();
now = GetSystemMs();
if(now - tick > 1000)
{
printf("ava_interval:%d\n",ava_interval);
tick = now;
}
}
CleanNetSystem();
return 0;
}
int
setup_signal_delivery (void)
{
// Make the sigset_t consisting of the completion signal.
if (sigemptyset (&completion_signal) == -1)
{
perror ("Error:Couldnt init the RT completion signal set\n");
return -1;
}
if (sigaddset (&completion_signal, SIGRTMIN) == -1)
{
perror ("Error:Couldnt init the RT completion signal set\n");
return -1;
}
// Mask them.
if (pthread_sigmask (SIG_BLOCK, &completion_signal, 0) == -1)
{
perror ("Error:Couldnt maks the RT completion signals\n");
return -1;
}
return setup_signal_handler (SIGRTMIN);
}
static void kwrapper_run( pid_t pid )
{
kwrapper_pid = pid;
setup_signals();
for(;;)
{
sleep( 1 ); /* poll and see if the real process is still alive */
if( got_sig != last_sig ) /* did we get a signal ? */
{
last_sig = got_sig;
if( got_sig == SIGCHLD )
; /* nothing, ignore */
else if( got_sig == SIGCONT )
; /* done in signal handler */
else /* do the default action ( most of them quit the app ) */
{
setup_signal_handler( got_sig, 1 );
raise( got_sig ); /* handle the signal again */
}
}
if( kill( pid, 0 ) < 0 )
break;
}
/* I'm afraid it won't be that easy to get the return value ... */
}
void qcgc_initialize(void) {
initialize_shadowstack();
qcgc_state.prebuilt_objects = qcgc_object_stack_create(16); // XXX
qcgc_state.weakrefs = qcgc_weakref_bag_create(16); // XXX
qcgc_state.gp_gray_stack = qcgc_object_stack_create(16); // XXX
qcgc_state.gray_stack_size = 0;
qcgc_state.phase = GC_PAUSE;
qcgc_state.cells_since_incmark = 0;
qcgc_state.incmark_since_sweep = 0;
qcgc_state.free_cells = 0;
qcgc_state.largest_free_block = 0;
qcgc_allocator_initialize();
qcgc_hbtable_initialize();
qcgc_event_logger_initialize();
#if LOG_ALLOCATOR_SWITCH
qcgc_allocations = 0;
#endif
env_or_fallback(qcgc_state.incmark_threshold,
"QCGC_INCMARK", QCGC_INCMARK_THRESHOLD);
env_or_fallback(qcgc_state.incmark_to_sweep,
"QCGC_INCMARK_TO_SWEEP", QCGC_INCMARK_TO_SWEEP);
setup_signal_handler();
}
int init_client(mdbCli mdbcli) {
/*注册信号处理函数
* */
setup_signal_handler();
listen_sock = cli_connect(mdbcli);
return 0;
}
int main(int argc,char **argv)
{
//msgque_flush_time = 5;
setup_signal_handler();
InitNetSystem();
//共用网络层，两个线程各运行一个echo服务
wpacket_allocator = new_obj_allocator(sizeof(struct wpacket),8192);
rpacket_allocator = new_obj_allocator(sizeof(struct rpacket),8192);
asynnet_t asynet = asynnet_new(2);
msgdisp_t disp1 = new_msgdisp(asynet,5,
CB_CONNECT(asynconnect),
CB_CONNECTED(asynconnected),
CB_DISCNT(asyndisconnected),
CB_PROCESSPACKET(asynprocesspacket),
CB_CONNECTFAILED(asynconnectfailed));
/*msgdisp_t disp2 = new_msgdisp(asynet,
asynconnect,
asynconnected,
asyndisconnected,
asynprocesspacket,
asynconnectfailed);
*/
thread_t service1 = create_thread(THREAD_JOINABLE);
//thread_t service2 = create_thread(THREAD_JOINABLE);
ip = argv[1];
port = atoi(argv[2]);
thread_start_run(service1,service_main,(void*)disp1);
//sleepms(1000);
//thread_start_run(service2,service_main,(void*)disp2);
uint32_t tick,now;
tick = now = GetSystemMs();
while(!stop){
sleepms(1000);
now = GetSystemMs();
//if(now - tick > 1000)
{
uint32_t elapse = now-tick;
recvsize = (recvsize/elapse)/1000;
printf("client_count:%d,recvsize:%d,recvcount:%d\n",client_count,recvsize,recvcount);
tick = now;
packet_send_count = 0;
recvcount = 0;
recvsize = 0;
}
}
thread_join(service1);
//thread_join(service2);
CleanNetSystem();
return 0;
}
int main (int argc, char * const argv[])
{
const char* csv_filename = NULL;
const char* addr = NULL;
const char* port = NULL;
//parsing command line args
int opt;
while ((opt = getopt(argc, argv, "f:")) != -1) {
switch ( opt ) {
case 'f':
csv_filename = optarg;
break;
default:
usage(argv[0]);
return 1;
}
}
if (optind >=(argc-1)) {
usage(argv[0]);
return 1;
}
addr = argv[optind];
port = argv[optind+1];
//end of parsing
registerAllTuples();
setup_signal_handler();
g_txnManager = initTxnManager(); // new
myAddr = UDPAddress(addr, atoi(port) );
UdpSocket u("", atoi(port) );
u.init();
g_udp = &u;
TxnContext ctx = g_txnManager->create();
facts(ctx);
if (csv_filename)
csv_facts(csv_filename, ctx);
//taskQ.commitTables();
ctx.deltaQ.commitTables();
view_maintenance( ctx );
std::cout << "taskQ size=" << taskQ.size() << std::endl;
g_txnManager->commit(ctx);
Event e = Event(Event::NONE, NULL);
callLater(0, boost::bind(demux, e));
u.enableRead();
register_periodics();
iosv.run();
return (0);
}
/* everything starts here */
int main(void)
{
/* ignore SIGINT */
setup_signal_handler(SIGINT, SIG_IGN);
setup_remaining_signal_handlers();
char * line;
/* variables to build prompt */
char *user;
char hostname[256];
/* create custom prompt text */
prompt = malloc(1024);
memset(prompt, 0, 1024); //??
/* setting user variables for prompt */
if (getcwd(cwd, sizeof(cwd)) == NULL)
perror("getcwd() error");
user = getenv("USER");
gethostname(hostname,256);
sprintf(prompt, "%s@%s:~%s$ ", user, hostname, cwd);
printf("\nWilkommen!\n");
/* continue until user signals exit i.e. writes 'quit' */
while(!quit) {
/* input cursor with prompt */
line = readline(prompt);
/* process input */
processLine(line);
if(parser_status != PARSER_OK) // ERROR-Messages des Parsers ausgeben
printf("%s\n", parser_message);
sprintf(prompt, "%s@%s:~%s$ ", user, hostname, cwd);
/* sanity checks for history i.e. actual text in line */
if (line && *line) {
/* add line to history */
add_history(line);
}
/* return heap space i.e. readline dynamically allocates space for input */
free(line);
}
/* success */
return EXIT_SUCCESS;
}
int main(int argc,char **argv)
{
setup_signal_handler();
InitNetSystem();
struct netservice *tcpclient = new_service();
tcpclient->connect(tcpclient,"127.0.0.1",8010,(void*)tcpclient,on_connect,10000);
while(!stop){
tcpclient->loop(tcpclient,50);
}
destroy_service(&tcpclient);
CleanNetSystem();
return 0;
}
/* handles SIGUSR2 and SIGHUP only */
static void do_restart(int sig)
{
setenv(REEXEC_FLAG, "1", 1);
fprintf(stderr, SD_NOTICE "haproxy-systemd-wrapper: re-executing on %s.\n",
sig == SIGUSR2 ? "SIGUSR2" : "SIGHUP");
/* don't let the other process take one of those signals by accident */
pause_signal_handler();
execv(wrapper_argv[0], wrapper_argv);
/* failed, let's reinstall the signal handler and continue */
setup_signal_handler();
fprintf(stderr, SD_NOTICE "haproxy-systemd-wrapper: re-exec(%s) failed.\n", wrapper_argv[0]);
}
int test_copy_unaligned(void)
{
/* Only run this test on a P9 or later */
SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00));
/* Register our signal handler with SIGBUS */
setup_signal_handler();
/* +1 makes buf unaligned */
copy(cacheline_buf+1);
/* We should not get here */
return 1;
}
int main(int argc, char **argv)
{
int status;
setup_signal_handler();
wrapper_argc = argc;
wrapper_argv = argv;
--argc; ++argv;
init(argc, argv);
if (getenv(REEXEC_FLAG) != NULL) {
/* We are being re-executed: restart HAProxy gracefully */
int i;
char **pid_strv = NULL;
int nb_pid = read_pids(&pid_strv);
unsetenv(REEXEC_FLAG);
spawn_haproxy(pid_strv, nb_pid);
for (i = 0; i < nb_pid; ++i)
free(pid_strv[i]);
free(pid_strv);
}
else {
/* Start a fresh copy of HAProxy */
spawn_haproxy(NULL, 0);
}
status = -1;
while (caught_signal || wait(&status) != -1 || errno == EINTR) {
int sig = caught_signal;
if (caught_signal == SIGUSR2 || caught_signal == SIGHUP) {
caught_signal = 0;
do_restart(sig);
}
else if (caught_signal == SIGINT || caught_signal == SIGTERM) {
caught_signal = 0;
do_shutdown(sig);
}
}
fprintf(stderr, SD_NOTICE "haproxy-systemd-wrapper: exit, haproxy RC=%d\n",
status);
return status;
}
/**
* Get arguments from standard in and execute the commands. e
*/
int main(int argc, char *argv[]) {
char command[CMD_LEN];
int len;
if (SIGDET)
setup_signal_handler();
setup_sigterm_handler();
while (is_running) {
char *args[ARGS_SIZE] = {0};
memset(command, 0, CMD_LEN);
if(!SIGDET) poll_background_children();
setup_interrupt_signal_handler();
/* Command prompt */
if (SAY_TURTLE) system("say \"turtle\"");
printf(" \xF0\x9F\x90\xA2 " ANSI_COLOR_GREEN);
fgets(command, CMD_LEN, stdin);
remove_trailing_nl(command);
tokenize(command, args);
putz(ANSI_COLOR_RESET);
/* Now the fun stuff */
len = count_non_null(args);
if (*(args[len - 1]) == '&') {
args[len - 1] = 0;
background(args);
} else if (!handle_builtin(args) && strlen(args[0]) != 0) {
foreground(args);
}
}
return 0;
}
int main(int argc, char **argv)
{
int err = 0;
lua_State *L;
setup_signal_handler();
/* parse args once to read config file location */
if (parse_args(argc, argv, &err) != 0) {
return err;
}
/* ini file sets defaults for arguments*/
parse_config(inifile);
if (!global.inifile) {
log_error("could not open ini configuration %s\n", inifile);
}
/* parse arguments again, to override ini file */
parse_args(argc, argv, &err);
log_open(logfile);
locale_init();
#ifdef CRTDBG
init_crtdbg();
#endif
L = lua_init();
game_init();
bind_monsters(L);
err = eressea_run(L, luafile);
if (err) {
log_error("script %s failed with code %d\n", luafile, err);
return err;
}
#ifdef MSPACES
malloc_stats();
#endif
game_done();
lua_done(L);
log_close();
if (global.inifile) {
iniparser_freedict(global.inifile);
}
return 0;
}
void setup_remaining_signal_handlers(void)
{
/* SIGINT intentionally missing from this list */
/* SIGKILL and SIGSTOP can't be caught */
int signals[] = { SIGHUP, SIGQUIT, SIGILL, SIGTRAP, SIGABRT, SIGFPE,
SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD,
SIGCONT, SIGTSTP, SIGTTIN, SIGTTOU, //man kill
};
const unsigned int signals_count = sizeof(signals)/sizeof(int);
unsigned int i;
for (i=0; i<signals_count; ++i) {
setup_signal_handler(signals[i], signal_handler);
}
}
int main(int argc, char **argv)
{
int err, result = 0;
lua_State *L;
setup_signal_handler();
parse_config(inifile);
log_open(logfile);
err = parse_args(argc, argv, &result);
if (err) {
return result;
}
locale_init();
#ifdef CRTDBG
init_crtdbg();
#endif
L = lua_init();
game_init();
register_races();
register_borders();
register_spells();
bind_monsters(L);
err = eressea_run(L, luafile);
if (err) {
log_error("server execution failed with code %d\n", err);
return err;
}
#ifdef MSPACES
malloc_stats();
#endif
game_done();
lua_done(L);
log_close();
if (global.inifile) {
iniparser_free(global.inifile);
}
return 0;
}
int main(int argc,char **argv)
{
setup_signal_handler();
InitNetSystem();
asynnet_t asynet = asynnet_new(3);//3个poller,1个用于监听,1个用于处理客户端连接，1个用于处理服务器连接
msgdisp_t disp_to_server = new_msgdisp(asynet,3,
CB_CONNECT(to_server_connect),
CB_CONNECTED(to_server_connected),
CB_PROCESSPACKET(to_server_process));
msgdisp_t disp_to_client = new_msgdisp(asynet,2,
CB_CONNECT(to_client_connect),
CB_ASYNPROCESSPACKET(to_client_process));
thread_t service1 = create_thread(THREAD_JOINABLE);
thread_t service2 = create_thread(THREAD_JOINABLE);
to_client_ip = argv[1];
to_client_port = atoi(argv[2]);
to_server_ip = argv[3];
to_server_port = atoi(argv[4]);
thread_start_run(service1,service_toserver,(void*)disp_to_server);
sleepms(1000);
thread_start_run(service2,service_toclient,(void*)disp_to_client);
while(!stop){
sleepms(100);
}
thread_join(service1);
thread_join(service2);
CleanNetSystem();
return 0;
}
int main(int argc,char **argv)
{
setup_signal_handler();
msgdisp_t disp1 = new_msgdisp(NULL,0);
thread_t service1 = create_thread(THREAD_JOINABLE);
msgdisp_t disp2 = new_msgdisp(NULL,0);
thread_t service2 = create_thread(THREAD_JOINABLE);
asydb = new_asyndb();
asydb->connectdb(asydb,"127.0.0.1",6379);
asydb->connectdb(asydb,"127.0.0.1",6379);
//发出第一个请求uu
char req[256];
snprintf(req,256,"set key%d %d",g,g);
asydb->request(asydb,new_dbrequest(db_set,req,db_setcallback,disp1,disp1));
thread_start_run(service1,service_main,(void*)disp1);
asydb->request(asydb,new_dbrequest(db_set,req,db_setcallback,disp2,disp2));
thread_start_run(service2,service_main,(void*)disp2);
uint32_t tick,now;
tick = now = GetSystemMs();
while(!stop){
sleepms(100);
now = GetSystemMs();
if(now - tick > 1000)
{
printf("count:%d\n",count);
tick = now;
count = 0;
}
}
thread_join(service1);
thread_join(service2);
return 0;
}
static int
setup_signal_delivery (void)
{
// = Mask all the signals.
sigset_t full_set;
// Get full set.
if (ACE_OS::sigfillset (&full_set) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Error:(%P | %t):%p\n",
"sigfillset failed"),
-1);
// Mask them.
if (ACE_OS::pthread_sigmask (SIG_SETMASK, &full_set, 0) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Error:(%P | %t):%p\n",
"pthread_sigmask failed"),
-1);
// = Make a mask with SIGRTMIN only. We use only that signal to
// issue <aio_>'s.
if (ACE_OS::sigemptyset (&completion_signal) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "Error: %p\n",
"Couldnt init the RT completion signal set"),
-1);
if (ACE_OS::sigaddset (&completion_signal,
SIGRTMIN) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "Error: %p\n",
"Couldnt init the RT completion signal set"),
-1);
// Set up signal handler for this signal.
return setup_signal_handler (SIGRTMIN);
}
int main(int argc, char **argv)
{
int err = 0;
lua_State *L;
dictionary *d = 0;
setup_signal_handler();
message_handle_missing(MESSAGE_MISSING_REPLACE);
/* parse arguments again, to override ini file */
err = parse_args(argc, argv);
if (err != 0) {
return (err > 0) ? 0 : err;
}
d = parse_config(inifile);
if (!d) {
log_error("could not open ini configuration %s\n", inifile);
}
locale_init();
L = lua_init(d);
game_init();
bind_monsters(L);
err = eressea_run(L, luafile);
if (err) {
log_error("script %s failed with code %d\n", luafile, err);
return err;
}
game_done();
lua_done(L);
log_close();
stats_write(stdout, "");
stats_close();
if (d) {
iniparser_freedict(d);
}
return 0;
}
int main(int argc,char **argv)
{
mutil_thread = 0;
setup_signal_handler();
init_clients();
InitNetSystem();
struct netservice *tcpserver = new_service();
tcpserver->listen(tcpserver,argv[1],atoi(argv[2]),(void*)tcpserver,accept_client);
uint32_t tick,now;
tick = now = GetSystemMs();
while(!stop){
tcpserver->loop(tcpserver,50);
now = GetSystemMs();
if(now - tick > 1000)
{
printf("client_count:%d,send_count:%d\n",client_count,(packet_send_count*1000)/(now-tick));
tick = now;
packet_send_count = 0;
}
}
destroy_service(&tcpserver);
CleanNetSystem();
return 0;
}
int
main (int argc, char *argv[]) {
char *dictfile = DICT_FILE;
FILE *dict;
char word[MAX_WORD_LEN];
int sock, ret;
struct in_addr rcvr_addr;
struct sockaddr_in name;
struct ip_mreq mreq;
#if BEW
struct sockaddr_in local;
#endif
program_type prog_type = unknown;
sec_serv_t sec_servs = sec_serv_none;
unsigned char ttl = 5;
int c;
int key_size = 128;
int tag_size = 8;
int gcm_on = 0;
char *input_key = NULL;
char *address = NULL;
char key[MAX_KEY_LEN];
unsigned short port = 0;
rtp_sender_t snd;
srtp_policy_t policy;
err_status_t status;
int len;
int do_list_mods = 0;
uint32_t ssrc = 0xdeadbeef; /* ssrc value hardcoded for now */
#ifdef RTPW_USE_WINSOCK2
WORD wVersionRequested = MAKEWORD(2, 0);
WSADATA wsaData;
ret = WSAStartup(wVersionRequested, &wsaData);
if (ret != 0) {
fprintf(stderr, "error: WSAStartup() failed: %d\n", ret);
exit(1);
}
#endif
if (setup_signal_handler(argv[0]) != 0) {
exit(1);
}
/* initialize srtp library */
status = srtp_init();
if (status) {
printf("error: srtp initialization failed with error code %d\n", status);
exit(1);
}
/* check args */
while (1) {
c = getopt_s(argc, argv, "k:rsgt:ae:ld:");
if (c == -1) {
break;
}
switch (c) {
case 'k':
input_key = optarg_s;
break;
case 'e':
key_size = atoi(optarg_s);
if (key_size != 128 && key_size != 256) {
printf("error: encryption key size must be 128 or 256 (%d)\n", key_size);
exit(1);
}
sec_servs |= sec_serv_conf;
break;
case 't':
tag_size = atoi(optarg_s);
if (tag_size != 8 && tag_size != 16) {
printf("error: GCM tag size must be 8 or 16 (%d)\n", tag_size);
exit(1);
}
break;
case 'a':
sec_servs |= sec_serv_auth;
break;
case 'g':
gcm_on = 1;
sec_servs |= sec_serv_auth;
break;
case 'r':
prog_type = receiver;
break;
case 's':
prog_type = sender;
break;
case 'd':
status = crypto_kernel_set_debug_module(optarg_s, 1);
if (status) {
printf("error: set debug module (%s) failed\n", optarg_s);
exit(1);
}
break;
case 'l':
do_list_mods = 1;
break;
default:
usage(argv[0]);
}
}
if (prog_type == unknown) {
if (do_list_mods) {
status = crypto_kernel_list_debug_modules();
if (status) {
printf("error: list of debug modules failed\n");
exit(1);
}
return 0;
} else {
printf("error: neither sender [-s] nor receiver [-r] specified\n");
usage(argv[0]);
}
}
if ((sec_servs && !input_key) || (!sec_servs && input_key)) {
/*
* a key must be provided if and only if security services have
* been requested
*/
usage(argv[0]);
}
if (argc != optind_s + 2) {
/* wrong number of arguments */
usage(argv[0]);
}
/* get address from arg */
address = argv[optind_s++];
/* get port from arg */
port = atoi(argv[optind_s++]);
/* set address */
#ifdef HAVE_INET_ATON
if (0 == inet_aton(address, &rcvr_addr)) {
fprintf(stderr, "%s: cannot parse IP v4 address %s\n", argv[0], address);
exit(1);
}
if (rcvr_addr.s_addr == INADDR_NONE) {
fprintf(stderr, "%s: address error", argv[0]);
exit(1);
}
#else
rcvr_addr.s_addr = inet_addr(address);
if (0xffffffff == rcvr_addr.s_addr) {
fprintf(stderr, "%s: cannot parse IP v4 address %s\n", argv[0], address);
exit(1);
}
#endif
/* open socket */
sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock < 0) {
int err;
#ifdef RTPW_USE_WINSOCK2
err = WSAGetLastError();
#else
err = errno;
#endif
fprintf(stderr, "%s: couldn't open socket: %d\n", argv[0], err);
exit(1);
}
name.sin_addr = rcvr_addr;
name.sin_family = PF_INET;
name.sin_port = htons(port);
if (ADDR_IS_MULTICAST(rcvr_addr.s_addr)) {
if (prog_type == sender) {
ret = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, &ttl,
sizeof(ttl));
if (ret < 0) {
fprintf(stderr, "%s: Failed to set TTL for multicast group", argv[0]);
perror("");
exit(1);
}
}
mreq.imr_multiaddr.s_addr = rcvr_addr.s_addr;
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
ret = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void*)&mreq,
sizeof(mreq));
if (ret < 0) {
fprintf(stderr, "%s: Failed to join multicast group", argv[0]);
perror("");
exit(1);
}
}
/* report security services selected on the command line */
printf("security services: ");
if (sec_servs & sec_serv_conf)
printf("confidentiality ");
if (sec_servs & sec_serv_auth)
printf("message authentication");
if (sec_servs == sec_serv_none)
printf("none");
printf("\n");
/* set up the srtp policy and master key */
if (sec_servs) {
/*
* create policy structure, using the default mechanisms but
* with only the security services requested on the command line,
* using the right SSRC value
*/
switch (sec_servs) {
case sec_serv_conf_and_auth:
if (gcm_on) {
#ifdef OPENSSL
switch (key_size) {
case 128:
crypto_policy_set_aes_gcm_128_8_auth(&policy.rtp);
crypto_policy_set_aes_gcm_128_8_auth(&policy.rtcp);
break;
case 256:
crypto_policy_set_aes_gcm_256_8_auth(&policy.rtp);
crypto_policy_set_aes_gcm_256_8_auth(&policy.rtcp);
break;
}
#else
printf("error: GCM mode only supported when using the OpenSSL crypto engine.\n");
return 0;
#endif
} else {
switch (key_size) {
case 128:
crypto_policy_set_rtp_default(&policy.rtp);
crypto_policy_set_rtcp_default(&policy.rtcp);
break;
case 256:
crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy.rtp);
crypto_policy_set_rtcp_default(&policy.rtcp);
break;
}
}
break;
case sec_serv_conf:
if (gcm_on) {
printf("error: GCM mode must always be used with auth enabled\n");
return -1;
} else {
switch (key_size) {
case 128:
crypto_policy_set_aes_cm_128_null_auth(&policy.rtp);
crypto_policy_set_rtcp_default(&policy.rtcp);
break;
case 256:
crypto_policy_set_aes_cm_256_null_auth(&policy.rtp);
crypto_policy_set_rtcp_default(&policy.rtcp);
break;
}
}
break;
case sec_serv_auth:
if (gcm_on) {
#ifdef OPENSSL
switch (key_size) {
case 128:
crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtp);
crypto_policy_set_aes_gcm_128_8_only_auth(&policy.rtcp);
break;
case 256:
crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtp);
crypto_policy_set_aes_gcm_256_8_only_auth(&policy.rtcp);
break;
}
#else
printf("error: GCM mode only supported when using the OpenSSL crypto engine.\n");
return 0;
#endif
} else {
crypto_policy_set_null_cipher_hmac_sha1_80(&policy.rtp);
crypto_policy_set_rtcp_default(&policy.rtcp);
}
break;
default:
printf("error: unknown security service requested\n");
return -1;
}
policy.ssrc.type = ssrc_specific;
policy.ssrc.value = ssrc;
policy.key = (uint8_t *) key;
policy.ekt = NULL;
policy.next = NULL;
policy.window_size = 128;
policy.allow_repeat_tx = 0;
policy.rtp.sec_serv = sec_servs;
policy.rtcp.sec_serv = sec_serv_none; /* we don't do RTCP anyway */
if (gcm_on && tag_size != 8) {
policy.rtp.auth_tag_len = tag_size;
}
/*
* read key from hexadecimal on command line into an octet string
*/
len = hex_string_to_octet_string(key, input_key, policy.rtp.cipher_key_len*2);
/* check that hex string is the right length */
if (len < policy.rtp.cipher_key_len*2) {
fprintf(stderr,
"error: too few digits in key/salt "
"(should be %d hexadecimal digits, found %d)\n",
policy.rtp.cipher_key_len*2, len);
exit(1);
}
if (strlen(input_key) > policy.rtp.cipher_key_len*2) {
fprintf(stderr,
"error: too many digits in key/salt "
"(should be %d hexadecimal digits, found %u)\n",
policy.rtp.cipher_key_len*2, (unsigned)strlen(input_key));
exit(1);
}
printf("set master key/salt to %s/", octet_string_hex_string(key, 16));
printf("%s\n", octet_string_hex_string(key+16, 14));
} else {
/*
* we're not providing security services, so set the policy to the
* null policy
*
* Note that this policy does not conform to the SRTP
* specification, since RTCP authentication is required. However,
* the effect of this policy is to turn off SRTP, so that this
* application is now a vanilla-flavored RTP application.
*/
policy.key = (uint8_t *)key;
policy.ssrc.type = ssrc_specific;
policy.ssrc.value = ssrc;
policy.rtp.cipher_type = NULL_CIPHER;
policy.rtp.cipher_key_len = 0;
policy.rtp.auth_type = NULL_AUTH;
policy.rtp.auth_key_len = 0;
policy.rtp.auth_tag_len = 0;
policy.rtp.sec_serv = sec_serv_none;
policy.rtcp.cipher_type = NULL_CIPHER;
policy.rtcp.cipher_key_len = 0;
policy.rtcp.auth_type = NULL_AUTH;
policy.rtcp.auth_key_len = 0;
policy.rtcp.auth_tag_len = 0;
policy.rtcp.sec_serv = sec_serv_none;
policy.window_size = 0;
policy.allow_repeat_tx = 0;
policy.ekt = NULL;
policy.next = NULL;
}
if (prog_type == sender) {
#if BEW
/* bind to local socket (to match crypto policy, if need be) */
memset(&local, 0, sizeof(struct sockaddr_in));
local.sin_addr.s_addr = htonl(INADDR_ANY);
local.sin_port = htons(port);
ret = bind(sock, (struct sockaddr *) &local, sizeof(struct sockaddr_in));
if (ret < 0) {
fprintf(stderr, "%s: bind failed\n", argv[0]);
perror("");
exit(1);
}
#endif /* BEW */
/* initialize sender's rtp and srtp contexts */
snd = rtp_sender_alloc();
if (snd == NULL) {
fprintf(stderr, "error: malloc() failed\n");
exit(1);
}
rtp_sender_init(snd, sock, name, ssrc);
status = rtp_sender_init_srtp(snd, &policy);
if (status) {
fprintf(stderr,
"error: srtp_create() failed with code %d\n",
status);
exit(1);
}
/* open dictionary */
dict = fopen (dictfile, "r");
if (dict == NULL) {
fprintf(stderr, "%s: couldn't open file %s\n", argv[0], dictfile);
if (ADDR_IS_MULTICAST(rcvr_addr.s_addr)) {
leave_group(sock, mreq, argv[0]);
}
exit(1);
}
/* read words from dictionary, then send them off */
while (!interrupted && fgets(word, MAX_WORD_LEN, dict) != NULL) {
len = strlen(word) + 1; /* plus one for null */
if (len > MAX_WORD_LEN)
printf("error: word %s too large to send\n", word);
else {
rtp_sendto(snd, word, len);
printf("sending word: %s", word);
}
usleep(USEC_RATE);
}
rtp_sender_deinit_srtp(snd);
rtp_sender_dealloc(snd);
fclose(dict);
} else { /* prog_type == receiver */
rtp_receiver_t rcvr;
if (bind(sock, (struct sockaddr *)&name, sizeof(name)) < 0) {
close(sock);
fprintf(stderr, "%s: socket bind error\n", argv[0]);
perror(NULL);
if (ADDR_IS_MULTICAST(rcvr_addr.s_addr)) {
leave_group(sock, mreq, argv[0]);
}
exit(1);
}
rcvr = rtp_receiver_alloc();
if (rcvr == NULL) {
fprintf(stderr, "error: malloc() failed\n");
exit(1);
}
rtp_receiver_init(rcvr, sock, name, ssrc);
status = rtp_receiver_init_srtp(rcvr, &policy);
if (status) {
fprintf(stderr,
"error: srtp_create() failed with code %d\n",
status);
exit(1);
}
/* get next word and loop */
while (!interrupted) {
len = MAX_WORD_LEN;
if (rtp_recvfrom(rcvr, word, &len) > -1)
printf("\tword: %s\n", word);
}
rtp_receiver_deinit_srtp(rcvr);
rtp_receiver_dealloc(rcvr);
}
if (ADDR_IS_MULTICAST(rcvr_addr.s_addr)) {
leave_group(sock, mreq, argv[0]);
}
#ifdef RTPW_USE_WINSOCK2
ret = closesocket(sock);
#else
ret = close(sock);
#endif
if (ret < 0) {
fprintf(stderr, "%s: Failed to close socket", argv[0]);
perror("");
}
status = srtp_shutdown();
if (status) {
printf("error: srtp shutdown failed with error code %d\n", status);
exit(1);
}
#ifdef RTPW_USE_WINSOCK2
WSACleanup();
#endif
return 0;
}
/*
* main()
*/
extern int main(int argc, char** argv) {
cl_com_handle_t* handle = NULL;
cl_com_message_t* message = NULL;
cl_com_endpoint_t* sender = NULL;
cl_ssl_setup_t ssl_config;
cl_framework_t framework = CL_CT_TCP;
int ret_val = CL_RETVAL_OK;
const int fd_in = 0;
const int fd_out = 1;
char fd_in_data[255];
char fd_out_data[255];
char* reg = NULL;
int error = CL_RETVAL_OK;
reg = "reg";
fd_in_data[0] = '\0';
fd_out_data[0] = '\0';
/* check command line argument count */
if (argc <= 3) {
usage();
exit(1);
}
/* get service host and port as also the connection mode from command line */
server_host = argv[1];
handle_port = atoi(argv[2]);
if (handle_port <= 0) {
fprintf(stderr,"need a port number > 0\n");
usage();
exit(1);
}
if (argv[3]) {
if (strcmp(argv[3], "SSL") == 0) {
framework=CL_CT_SSL;
printf("using SSL framework\n");
}
}else{
printf("using TCP framework\n");
}
/* set the ssl environment */
if(framework == CL_CT_SSL){
memset(&ssl_config, 0, sizeof(ssl_config));
ssl_config.ssl_method = CL_SSL_v23; /* v23 method */
ssl_config.ssl_CA_cert_pem_file = getenv("SSL_CA_CERT_FILE"); /* CA certificate file */
ssl_config.ssl_CA_key_pem_file = NULL; /* private certificate file of CA (not used) */
ssl_config.ssl_cert_pem_file = getenv("SSL_CERT_FILE"); /* certificates file */
ssl_config.ssl_key_pem_file = getenv("SSL_KEY_FILE"); /* key file */
ssl_config.ssl_rand_file = getenv("SSL_RAND_FILE"); /* rand file (if RAND_status() not ok) */
ssl_config.ssl_crl_file = getenv("SSL_CRL_FILE"); /* revocation list file */
ssl_config.ssl_reconnect_file = NULL; /* file for reconnect data (not used) */
ssl_config.ssl_refresh_time = 0; /* key alive time for connections (not used) */
ssl_config.ssl_password = NULL; /* password for encrypted keyfiles (not used) */
ssl_config.ssl_verify_func = my_ssl_verify_func; /* function callback for peer user/name check */
if (ssl_config.ssl_CA_cert_pem_file == NULL ||
ssl_config.ssl_cert_pem_file == NULL ||
ssl_config.ssl_key_pem_file == NULL ||
ssl_config.ssl_rand_file == NULL) {
printf("please set the following environment variables:\n");
printf("SSL_CA_CERT_FILE = CA certificate file\n");
printf("SSL_CERT_FILE = certificates file\n");
printf("SSL_KEY_FILE = key file\n");
printf("(optional) SSL_RAND_FILE = rand file (if RAND_status() not ok)\n");
}
}
/* setup signalhandling */
setup_signal_handler();
/* setup commlib */
error = cl_com_setup_commlib(CL_RW_THREAD, CL_LOG_OFF, NULL);
if(error != CL_RETVAL_OK){
fprintf(stderr, "cl_com_setup_commlib failed with: %s\n", cl_get_error_text(error));
}
/* setup commlib error function callback */
cl_com_set_error_func(on_communication_error);
if (framework == CL_CT_SSL) {
cl_com_specify_ssl_configuration(&ssl_config);
}
/* create communication handle */
handle=cl_com_create_handle(&error,
framework,
CL_CM_CT_MESSAGE,
false,
handle_port,
CL_TCP_DEFAULT,
"client", 0,
5, 0 );
if (handle == NULL) {
fprintf(stderr, "could not create communication handle with error: %s\n", cl_get_error_text(error));
cl_com_cleanup_commlib();
exit(1);
}
/* print out some info output */
printf("client running:\n");
printf("host: \"%s\"\n", handle->local->comp_host);
printf("name: \"%s\"\n", handle->local->comp_name);
printf("id: \"%ld\"\n", handle->local->comp_id);
ret_val = cl_com_external_fd_register(handle, fd_in, fd_in_cb, CL_R_SELECT, fd_in_data);
if (ret_val != CL_RETVAL_OK) {
printf("could not register stdin-fd: %s\n", cl_get_error_text(ret_val));
do_shutdown = 1;
}else{
printf("stdin-fd was registered\n");
}
ret_val = cl_com_external_fd_register(handle, fd_out, fd_out_cb, CL_W_SELECT, fd_out_data);
if (ret_val != CL_RETVAL_OK) {
printf("could not register stdout-fd: %s\n", cl_get_error_text(ret_val));
do_shutdown = 1;
}else{
printf("stdout-fd was registered\n");
}
/* register at the server */
ret_val = cl_commlib_send_message(handle,
server_host, "server", 1,
CL_MIH_MAT_NAK,
(cl_byte_t**)®, strlen(reg)+1,
NULL, 0, 0,
true, false);
if (ret_val != CL_RETVAL_OK) {
do_shutdown = 1;
}
/* application main loop */
while ( do_shutdown == 0 ) {
CL_LOG(CL_LOG_WARNING, "App: start looping");
cl_commlib_trigger(handle, 1);
CL_LOG(CL_LOG_WARNING, "App: trigger was done");
ret_val = cl_commlib_receive_message(handle,NULL, NULL, 0, false, 0, &message, &sender);
if (message != NULL) {
CL_LOG(CL_LOG_WARNING, "App: std_out received");
pthread_mutex_lock(&data_mutex);
CL_LOG(CL_LOG_WARNING, "App: std_out got mutex");
strcat(fd_out_data, (const char*)message->message);
pthread_mutex_unlock(&data_mutex);
CL_LOG(CL_LOG_WARNING, "App: std_out released mutex");
cl_com_external_fd_set_write_ready(handle, fd_out);
CL_LOG(CL_LOG_WARNING, "App: std_out set write ready flag");
cl_com_free_message(&message);
cl_com_free_endpoint(&sender);
}
pthread_mutex_lock(&data_in_mutex);
if(ready == 1) {
cl_byte_t* bp = NULL;
CL_LOG(CL_LOG_WARNING, "App: std_in send");
bp = (cl_byte_t*) fd_in_data;
cl_commlib_send_message(handle,
server_host, "server", 1,
CL_MIH_MAT_NAK,
&bp, strlen(fd_in_data)+1,
NULL, 0, 0,
true, false);
ready = 0;
fd_in_data[0] = '\0';
}
pthread_mutex_unlock(&data_in_mutex);
}
printf("shutting down ...\n");
cl_com_external_fd_unregister(handle, fd_in);
cl_com_external_fd_unregister(handle, fd_out);
/* here the application goes down - shutdown communication lib */
while ( cl_commlib_shutdown_handle(handle, true) == CL_RETVAL_MESSAGE_IN_BUFFER) {
message = NULL;
cl_commlib_receive_message(handle,NULL, NULL, 0, false, 0, &message, &sender);
if (message != NULL) {
printf("ignoring message from \"%s\"\n", sender->comp_host);
cl_com_free_message(&message);
cl_com_free_endpoint(&sender);
message = NULL;
}
}
/* cleanup commlib */
cl_com_cleanup_commlib();
return 0;
}
int main (void)
{
int err;
struct sockaddr addr;
socklen_t alen = sizeof(addr);
int lsocket, s, count;
char buf[C_CMD_BUF_SIZE];
MNLD_DATA_T *obj = &mnld_data;
lsocket = android_get_control_socket(SOCKET_MNL);
if (lsocket < 0) {
MND_ERR("fail to get socket from environment: %s\n",strerror(errno));
exit(1);
}
if (listen(lsocket, 5)) {
MND_ERR("listen on socket failed: %s\n", strerror(errno));
exit(1);
}
if (setup_signal_handler()) {
MND_ERR("setup_signal_handler: %d (%s)\n", errno, strerror(errno));
exit(1);
}
if (mnl_init()) {
MND_ERR("mnl_init: %d (%s)\n", errno, strerror(errno));
exit(1);
}
MND_MSG("listening..\n");
while(1) {
int eof, s = accept(lsocket, &addr, &alen);
if (s < 0) {
MND_ERR("Accept failed!! :%s\n", strerror(errno));
continue;
}
obj->cur_accept_socket = s;
fcntl(s, F_SETFD, FD_CLOEXEC);
if (epoll_init()) {
MND_ERR("epoll_init: %d (%s)\n", errno, strerror(errno));
exit(1);
}
MND_MSG("new connection\n");
for (;;) {
err = process();
if (err == ERR_REMOTE_HANGUP) {
MND_ERR("remote hangup (cleanup?), wait for new connection\n");
break;
} else if (err == ERR_MNL_DIED) {
MND_ERR("mnl process died, kill it\n");
kill_mnl_process();
} else if (errno == EINTR) {
continue;
} else if (err) {
MND_ERR("process data error: %d (%s)\n", errno, strerror(errno));
}
}
MND_MSG("closing connection\n");
close(s);
epoll_destroy();
}
MND_MSG("exit mnld \n!!");
return 0;
}
/*
* main()
*/
extern int main(int argc, char** argv) {
int handle_port = 0;
cl_com_handle_t* handle = NULL;
cl_com_message_t* message = NULL;
cl_com_endpoint_t* sender = NULL;
int i = 0;
/* check command line argument count */
if (argc != 2) {
usage();
exit(1);
}
/* get server port from command line */
handle_port = atoi(argv[1]);
if (handle_port <= 0) {
fprintf(stderr,"need a port number > 0\n");
usage();
exit(1);
}
/* setup signalhandling */
setup_signal_handler();
/* setup commlib */
cl_com_setup_commlib(CL_RW_THREAD, CL_LOG_WARNING, on_communication_log);
/* setup commlib error function callback */
cl_com_set_error_func(on_communication_error);
/* create communication handle */
handle=cl_com_create_handle(NULL,
CL_CT_TCP,
CL_CM_CT_MESSAGE,
true,
handle_port,
CL_TCP_DEFAULT,
"server", 1,
1, 0 );
if (handle == NULL) {
fprintf(stderr, "could not create communication handle\n");
cl_com_cleanup_commlib();
exit(1);
}
/* print out some info output */
printf("server running:\n");
printf("host: \"%s\"\n", handle->local->comp_host);
cl_com_get_service_port(handle,&i);
printf("port: %d\n", i);
printf("name: \"%s\"\n", handle->local->comp_name);
printf("id: %ld\n", handle->local->comp_id);
/* application main loop */
while(do_shutdown != 1) {
cl_commlib_trigger(handle, 1);
cl_commlib_receive_message(handle,NULL, NULL, 0, false, 0, &message, &sender);
if (message != NULL) {
char response_message[1024];
sprintf(response_message,"Welcome to demo service at host \"%s\"!", handle->local->comp_host);
printf("received message from \"%s/%s/%ld\": %s\n", sender->comp_host, sender->comp_name, sender->comp_id, message->message);
cl_commlib_send_message(handle,
sender->comp_host,
sender->comp_name,
sender->comp_id, CL_MIH_MAT_NAK,
(cl_byte_t**)&response_message,
strlen(response_message)+1,
NULL, 0, 0,
true,false);
message->message = NULL;
cl_com_free_message(&message);
cl_com_free_endpoint(&sender);
message = NULL;
}
}
printf("shutting down ...\n");
/* here the application goes down - shutdown communication lib */
while ( cl_commlib_shutdown_handle(handle, true) == CL_RETVAL_MESSAGE_IN_BUFFER) {
message = NULL;
cl_commlib_receive_message(handle,NULL, NULL, 0, false, 0, &message, &sender);
if (message != NULL) {
printf("ignoring message from \"%s\"\n", sender->comp_host);
cl_com_free_message(&message);
cl_com_free_endpoint(&sender);
message = NULL;
}
}
/* cleanup commlib */
cl_com_cleanup_commlib();
return 0;
}
int main(){
lua_State *L = luaL_newstate();
luaL_openlibs(L);
if (luaL_dofile(L,"gateconfig.lua")) {
const char * error = lua_tostring(L, -1);
lua_pop(L,1);
printf("%s\n",error);
return 0;
}
luaObject_t gatecfg = GETGLOBAL_OBJECT(L,"gateserver");
agentcount = GET_OBJ_FIELD(gatecfg,"agentservice_count",int,lua_tonumber);
release_luaObj(gatecfg);
luaObject_t toclicfg = GETGLOBAL_OBJECT(L,"toclient");
string_t cliip = new_string(GET_OBJ_FIELD(toclicfg,"ip",const char *,lua_tostring));
int cliport = GET_OBJ_FIELD(toclicfg,"port",int,lua_tonumber);
release_luaObj(toclicfg);
luaObject_t togamecfg = GETGLOBAL_OBJECT(L,"togame");
g_gameip = new_string(GET_OBJ_FIELD(togamecfg,"ip",const char *,lua_tostring));
g_gameport = GET_OBJ_FIELD(togamecfg,"port",int,lua_tonumber);
release_luaObj(togamecfg);
luaObject_t torediscfg = GETGLOBAL_OBJECT(L,"toredis");
g_redisip = new_string(GET_OBJ_FIELD(torediscfg,"ip",const char *,lua_tostring));
g_redisport = GET_OBJ_FIELD(torediscfg,"port",int,lua_tonumber);
release_luaObj(torediscfg);
lua_close(L);
InitNetSystem();
//两个poller,一个用于accept,一个用于数据传输
asynnet_t asynet = asynnet_new(1);
if(start_verifyservice() != 0){
SYS_LOG(LOG_ERROR,"start verifyservice failed\n");
return 0;
}
/*if(start_togame_service(asynet) != 0){
SYS_LOG(LOG_ERROR,"start togame service failed\n");
return 0;
}*/
uint8_t i;
for(i = 0; i < agentcount; ++i){
g_agents[i] = new_agentservice(i,asynet);
}
msgdisp_t listener = new_msgdisp(asynet,1,CB_CONNECT(agent_connect));
//开启对客户端的监听
int32_t err = 0;
listener->listen(listener,0,to_cstr(cliip),cliport,&err);
if(err != 0)
{
SYS_LOG(LOG_ERROR,"start listen failed:%d\n",err);
return 0;
}
setup_signal_handler();
while(!stop){
msg_loop(listener,500);
}
//stop_togame_service();
stop_verifyservice();
for(i = 0; i < agentcount; ++i){
stop_agentservice(g_agents[i]);
}
return 0;
}
int test_loopback()
{
int ret;
pthread_t rx_thread;
ret = setup_signal_handler();
if (ret < 0)
return 1;
ret = modem_setup();
if(ret) {
perror(": Failed to setup modem");
return ret;
}
ret = modem_reset();
if(ret) {
perror(": Failed to reset modem");
return 1;
}
ret = modem_start();
if(ret) {
perror(": Failed to start modem");
return 1;
}
ret = pthread_create(&rx_thread, NULL, rx_thread_fnc, NULL);
if(ret) {
perror(": Error - pthread_create");
return 1;
}
printf("Setup modem defaults\n");
defaults(INTERNAL_PACKET_GEN, IP_LOOPBACK_MODE);
if (INTERNAL_PACKET_GEN) {
sleep(1);
fill_in_internal_pgen_data();
printf("Sending 1 packet from internal IP\n");
reg_write(0x120, 1);
reg_write(0x120, 0);
sleep(3);
} else {
sleep(1);
printf("Sending data\n");
ret = receive_data();
sleep(3);
}
modem_stop();
pthread_join(rx_thread, NULL);
modem_close();
int i;
bool b = false;
for(i = 0; i < TX_BUF_SIZE-HEADER_DATA_SIZE; i++) {
b |= rx_buffer[i] != tx_buffer[i+HEADER_DATA_SIZE];
}
if (b) {
printf("\n---------RX|TX---------\n");
for(i = 0; i < TX_BUF_SIZE-HEADER_DATA_SIZE; i++) {
printf("%d %d\n", rx_buffer[i]>>0, tx_buffer[i+HEADER_DATA_SIZE]);
}
}
printf("Exiting test\n");
return (int) b;
}
int main(int argc, char * argv[])
{
const char * config_file_name = NULL;
bool daemon_mode = true;
pid_t pid;
/* Search command line for config file name
* */
for ( int i = 1; i < argc; ++i ) {
if ( strncmp(argv[i], "--config=", 9) == 0 ) {
config_file_name = argv[i] + 9;
}
else if ( strcmp(argv[i], "--no-daemon") == 0 ) {
daemon_mode = 0;
}
}
/* Read config file
* */
if ( !config_file_name ) {
config_file_name = ffsrv_find_config_file();
}
if ( config_file_name && !ffsrv_read_config_file(config_file_name) ) {
return EXIT_FAILURE;
}
/* Walk over command line again, overriding config file settings
* */
for ( int i = 1; i < argc; ++i ) {
char keyname[256] = "", keyvalue[256] = "";
sscanf(argv[i], "%255[^=]=%255s", keyname, keyvalue);
if ( !ffsrv_parse_option(keyname, keyvalue) ) {
return EXIT_FAILURE;
}
}
/* Become daemon if requested
* */
if ( daemon_mode ) {
if ( (pid = become_daemon()) == -1 ) {
fprintf(stderr, "become_daemon() fails: %s", strerror(errno));
return EXIT_FAILURE;
}
if ( pid != 0 ) {
return EXIT_SUCCESS; /* finish parrent process */
}
}
/* Setup log file name
* */
if ( !ffsrv.logfilename || !*ffsrv.logfilename ) {
free(ffsrv.logfilename);
if ( daemon_mode ) {
ffsrv.logfilename = strdup("ffsrv.log");
}
else {
ffsrv.logfilename = strdup("stderr");
}
}
set_logfilename(ffsrv.logfilename);
/* Setup singal handler
* */
if ( !setup_signal_handler() ) {
PDBG("setup_signal_handler() fails: %s", strerror(errno));
return EXIT_FAILURE;
}
/* Start actual server
* */
if ( !ffsrv_start() ) {
PDBG("ffsrv_start() fails: %s", strerror(errno));
return EXIT_FAILURE;
}
/* Sleep this thread */
while ( 42 ) {
sleep(1);
}
ffsrv_finish();
return EXIT_SUCCESS;
}
void
error_setup(void)
{
setup_signal_handler(SIGABRT);
}
static void setup_signals()
{
setup_signal_handler( SIGHUP, 0 );
setup_signal_handler( SIGINT, 0 );
setup_signal_handler( SIGQUIT, 0 );
setup_signal_handler( SIGILL, 0 ); /* e.g. this one is probably doesn't make sense to pass */
setup_signal_handler( SIGABRT, 0 ); /* but anyway ... */
setup_signal_handler( SIGFPE, 0 );
/* SIGKILL can't be handled :( */
setup_signal_handler( SIGSEGV, 0 );
setup_signal_handler( SIGPIPE, 0 );
setup_signal_handler( SIGALRM, 0 );
setup_signal_handler( SIGTERM, 0 );
setup_signal_handler( SIGUSR1, 0 );
setup_signal_handler( SIGUSR2, 0 );
setup_signal_handler( SIGCHLD, 0 ); /* is this a good idea ??? */
setup_signal_handler( SIGCONT, 0 ); /* SIGSTOP can't be handled, but SIGTSTP and SIGCONT can */
/* SIGSTOP */ /* which should be enough */
setup_signal_handler( SIGTSTP, 0 );
setup_signal_handler( SIGTTIN, 0 ); /* is this a good idea ??? */
setup_signal_handler( SIGTTOU, 0 ); /* is this a good idea ??? */
/* some more ? */
}
