void sig_handler_child ( int sig ) { // child got SIGUSR2 -> cleanup pidfile and exit remove_pidfile ( ); exit ( 0 ); }
int main(int argc, char *argv[]) { char *conffile = NULL; int request_kill = 0, show_message = 0; if (!read_parameters(argc, argv, &conffile, &request_kill, &show_message)) { print_usage(argv[0]); return 1; } /* read the config file; conffile = NULL means use the default. */ if (!read_config(conffile)) return 1; /* error reading the config file */ setup_defaults(); if (request_kill) { kill_server(); return 0; } if (show_message) { signal_message(); return 0; } setup_signals(); /* Init files and directories. * Start logging last, so that the log is only created if startup succeeds. */ if (!init_workdir() || !init_database() || !check_database() || !begin_logging()) return 1; if (!settings.nodaemon) { if (daemon(0, 0) == -1) { settings.nodaemon = TRUE; log_msg("could not detach from terminal: %s", strerror(errno)); return 1; } if (!create_pidfile()) return 1; } /* give this process and its children their own process group id for kill() */ setpgid(0, 0); report_startup(); runserver(); /* shutdown */ remove_pidfile(); end_logging(); close_database(); remove_unix_socket(); free_config(); return 0; }
int main(int argc, char **argv){ welcome(); init(argc, argv); signal(SIGPIPE, SIG_IGN); signal(SIGINT, signal_handler); signal(SIGTERM, signal_handler); run(argc, argv); remove_pidfile(); if(serv_link){ log_info("shutdown network"); delete serv_link; } if(ssdb){ log_debug("free ssdb"); delete ssdb; } if(conf){ log_debug("free conf"); delete conf; } log_info("ssdb server exit."); return 0; }
static void cleanup(int code) { remove_pidfile(pidfile); if (code > EXIT_FAILURE) kill_myself_with_sig(code); exit(code); }
static void gkrellmd_cleanup() { gkrellm_sys_main_cleanup(); gkrellm_log_cleanup(); remove_pidfile(); }
int main ( int argc, char **argv ) { int mode = 0; int ac_resusp = 0; int fix_rtc = 0; int opt; while (( opt = getopt ( argc, argv, "a:frs" )) != EOF ) { switch ( opt ) { case 's': mode = 's'; break; case 'r': mode = 'r'; break; case 'a': ac_resusp = atoi ( optarg ); if ( ac_resusp < 30 ) { ac_resusp = 120; fprintf ( stderr, "Warning: resuspend timeout must be >= 30 sec. -- now set to 120 sec\n" ); } break; case 'f': fix_rtc = 1; break; default: usage ( ); } } if ( geteuid ( ) != 0 ) { fprintf ( stderr, "You need root priviledges to run opiealarm." ); return 2; } if ( !mode ) usage ( ); parent_pid = getpid ( ); // kill running opiealarm opiealarm_was_running = kill_with_pidfile ( ); remove_pidfile ( ); switch ( mode ) { case 'r': opt = resume ( ac_resusp ); break; case 's': default : opt = suspend ( fix_rtc ); break; } parent_pid = 0; return opt; }
static void watchdog_shutdown(int sig UNUSED_PARAM) { static const char V = 'V'; remove_pidfile(CONFIG_PID_FILE_PATH "/watchdog.pid"); write(3, &V, 1); /* Magic, see watchdog-api.txt in kernel */ if (ENABLE_FEATURE_CLEAN_UP) close(3); _exit(EXIT_SUCCESS); }
int resume ( int resuspend ) { FILE *fp; // re-suspend when on AC (optional) when woken up via RTC if ( !opiealarm_was_running ) { // if opiealarm -s didn't wake up via RTC, the old process gets killed // by kill_by_pidfile(), which is recorded in opiealarm_was_running if ( resuspend && onac ( )) { time_t start, now; char *argv [4]; if ( !fork_with_pidfile ( )) return 4; // we can't wait for the resuspend timeout in the parent process. // so we fork and tell the parent it can exit immediatly kill ( parent_pid, SIGUSR1 ); // sleep <resuspend> seconds - this method is much more precise than sleep() ! time ( &start ); do { sleep ( 1 ); time ( &now ); } while (( now - start ) < resuspend ); if ( onac ( )) { // still on ac ? argv[0] = "qcop"; argv[1] = "QPE/Desktop"; argv[2] = "suspend()"; argv[3] = 0; // hard coded for now ...but needed // another way would be to simulate a power-button press setenv ( "LOGNAME", "root", 1 ); setenv ( "HOME", "/root", 1 ); setenv ( "LD_LIBRARY_PATH", "/opt/QtPalmtop/lib", 1 ); setenv ( "QTDIR", "/opt/QtPalmtop", 1 ); remove_pidfile ( ); // no need for system() since this process is no longer useful anyway execv ( OPIE_BINDIR "/qcop", argv ); perror ( "exec for qcop failed" ); return 5; } } } return 0; }
int Application::main(int argc, char **argv){ conf = NULL; welcome(); parse_args(argc, argv); init(); write_pid(); run(); remove_pidfile(); delete conf; return 0; }
void kill_process(){ int pid = read_pid(); if(pid == -1){ fprintf(stderr, "could not read pidfile: %s(%s)\n", app_args.pidfile.c_str(), strerror(errno)); exit(1); } if(kill(pid, 0) == -1 && errno == ESRCH){ fprintf(stderr, "process: %d not running\n", pid); remove_pidfile(); return; } int ret = kill(pid, SIGTERM); if(ret == -1){ fprintf(stderr, "could not kill process: %d(%s)\n", pid, strerror(errno)); exit(1); } while(file_exists(app_args.pidfile)){ usleep(100 * 1000); } }
static void on_seaf_server_exit(void) { if (pidfile) remove_pidfile (pidfile); }
/*---------------------------------------------------------------------------*/ int main(int argc, char *const argv[]) { struct xio_session *session; char url[256]; int i; struct sigaction sa; int c; char *addr = NULL; char *port = NULL; char *trans = NULL; struct xio_session_params params; struct xio_connection_params cparams; while (1) { c = getopt_long(argc, argv, "a:p:r:hdnV", longopts, NULL); if (c == -1) break; switch (c) { case 'a': addr = optarg; break; case 'p': port = optarg; break; case 'r': trans = optarg; break; case 'h': usage(argv[0], 0); case 'd': debug_flag++; nofork_flag++; break; case 'n': nofork_flag++; break; case 'V': printf("%s\n", PACKAGE_STRING); exit(0); break; default: usage(argv[0], 1); break; } } memset(&sa, 0, sizeof(sa)); sa.sa_handler = signal_handler; sigaction(SIGINT, &sa, NULL); sigaction(SIGTERM, &sa, NULL); sigaction(SIGQUIT, &sa, NULL); sigaction(SIGHUP, &sa, NULL); sa.sa_handler = SIG_IGN; sa.sa_flags = SA_RESTART; sigaction(SIGPIPE, &sa, NULL); if (!nofork_flag && daemon(0, 0)) { logerr("daemon() failed"); exit(1); } if (!debug_flag) { openlog("xioclntd", LOG_PID, LOG_DAEMON); use_syslog = 1; } /* Create the process PID file */ if (create_pidfile(pid_file) != 0) exit(EXIT_FAILURE); memset(&session_data, 0, sizeof(session_data)); memset(¶ms, 0, sizeof(params)); memset(&cparams, 0, sizeof(cparams)); /* initialize library */ xio_init(); /* create "hello world" message */ for (i = 0; i < QUEUE_DEPTH; i++) { memset(&session_data.req[i], 0, sizeof(session_data.req[i])); /* header */ session_data.req[i].out.header.iov_base = strdup("hello world header request"); session_data.req[i].out.header.iov_len = strlen((const char *) session_data.req[i].out.header.iov_base) + 1; /* iovec[0]*/ session_data.req[i].out.sgl_type = XIO_SGL_TYPE_IOV; session_data.req[i].out.data_iov.max_nents = XIO_IOVLEN; session_data.req[i].out.data_iov.sglist[0].iov_base = strdup("hello world iovec request"); session_data.req[i].out.data_iov.sglist[0].iov_len = strlen((const char *) session_data.req[i].out.data_iov.sglist[0].iov_base) + 1; session_data.req[i].out.data_iov.nents = 1; } /* create thread context for the client */ session_data.ctx = xio_context_create(NULL, 0, -1); /* create url to connect to */ if (trans) sprintf(url, "%s://%s:%s", trans, addr, port); else sprintf(url, "rdma://%s:%s", addr, port); params.type = XIO_SESSION_CLIENT; params.ses_ops = &ses_ops; params.user_context = &session_data; params.uri = url; reconnect: session = xio_session_create(¶ms); cparams.session = session; cparams.ctx = session_data.ctx; cparams.conn_user_context = &session_data; /* connect the session */ session_data.conn = xio_connect(&cparams); /* event dispatcher is now running */ xio_context_run_loop(session_data.ctx, XIO_INFINITE); if (reconnect_flag || reload_flag) { session_data.cnt = 0; if (reconnect_flag) sleep(1); reload_flag = 0; reconnect_flag = 0; goto reconnect; } /* normal exit phase */ logit(LOG_INFO, "exit signaled\n"); /* free the message */ for (i = 0; i < QUEUE_DEPTH; i++) { free(session_data.req[i].out.header.iov_base); free(session_data.req[i].out.data_iov.sglist[0].iov_base); } /* free the context */ xio_context_destroy(session_data.ctx); xio_shutdown(); remove_pidfile(); if (use_syslog) closelog(); return 0; }
int ifplugd_main(int argc UNUSED_PARAM, char **argv) { int iface_status; int delay_time; const char *iface_status_str; struct pollfd netlink_pollfd[1]; unsigned opts; const char *api_mode_found; #if ENABLE_FEATURE_PIDFILE char *pidfile_name; pid_t pid_from_pidfile; #endif INIT_G(); opt_complementary = "t+:u+:d+"; opts = getopt32(argv, OPTION_STR, &G.iface, &G.script_name, &G.poll_time, &G.delay_up, &G.delay_down, &G.api_mode, &G.extra_arg); G.poll_time *= 1000; applet_name = xasprintf("ifplugd(%s)", G.iface); #if ENABLE_FEATURE_PIDFILE pidfile_name = xasprintf(CONFIG_PID_FILE_PATH "/ifplugd.%s.pid", G.iface); pid_from_pidfile = read_pid(pidfile_name); if (opts & FLAG_KILL) { if (pid_from_pidfile > 0) /* Upstream tool use SIGINT for -k */ kill(pid_from_pidfile, SIGINT); return EXIT_SUCCESS; } if (pid_from_pidfile > 0 && kill(pid_from_pidfile, 0) == 0) bb_error_msg_and_die("daemon already running"); #endif api_mode_found = strchr(api_modes, G.api_mode[0]); if (!api_mode_found) bb_error_msg_and_die("unknown API mode '%s'", G.api_mode); G.api_method_num = api_mode_found - api_modes; if (!(opts & FLAG_NO_DAEMON)) bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv); xmove_fd(xsocket(AF_INET, SOCK_DGRAM, 0), ioctl_fd); if (opts & FLAG_MONITOR) { struct sockaddr_nl addr; int fd = xsocket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); memset(&addr, 0, sizeof(addr)); addr.nl_family = AF_NETLINK; addr.nl_groups = RTMGRP_LINK; addr.nl_pid = getpid(); xbind(fd, (struct sockaddr*)&addr, sizeof(addr)); xmove_fd(fd, netlink_fd); } write_pidfile(pidfile_name); /* this can't be moved before socket creation */ if (!(opts & FLAG_NO_SYSLOG)) { openlog(applet_name, 0, LOG_DAEMON); logmode |= LOGMODE_SYSLOG; } bb_signals(0 | (1 << SIGINT ) | (1 << SIGTERM) | (1 << SIGQUIT) | (1 << SIGHUP ) /* why we ignore it? */ /* | (1 << SIGCHLD) - run_script does not use it anymore */ , record_signo); bb_error_msg("started: %s", bb_banner); if (opts & FLAG_MONITOR) { struct ifreq ifrequest; set_ifreq_to_ifname(&ifrequest); G.iface_exists = (network_ioctl(SIOCGIFINDEX, &ifrequest, NULL) == 0); } if (G.iface_exists) maybe_up_new_iface(); iface_status = detect_link(); if (iface_status == IFSTATUS_ERR) goto exiting; iface_status_str = strstatus(iface_status); if (opts & FLAG_MONITOR) { bb_error_msg("interface %s", G.iface_exists ? "exists" : "doesn't exist, waiting"); } /* else we assume it always exists, but don't mislead user * by potentially lying that it really exists */ if (G.iface_exists) { bb_error_msg("link is %s", iface_status_str); } if ((!(opts & FLAG_NO_STARTUP) && iface_status == IFSTATUS_UP ) || (opts & FLAG_INITIAL_DOWN) ) { if (run_script(iface_status_str) != 0) goto exiting; } /* Main loop */ netlink_pollfd[0].fd = netlink_fd; netlink_pollfd[0].events = POLLIN; delay_time = 0; while (1) { int iface_status_old; int iface_exists_old; switch (bb_got_signal) { case SIGINT: case SIGTERM: bb_got_signal = 0; goto cleanup; case SIGQUIT: bb_got_signal = 0; goto exiting; default: bb_got_signal = 0; break; } if (poll(netlink_pollfd, (opts & FLAG_MONITOR) ? 1 : 0, G.poll_time ) < 0 ) { if (errno == EINTR) continue; bb_perror_msg("poll"); goto exiting; } iface_status_old = iface_status; iface_exists_old = G.iface_exists; if ((opts & FLAG_MONITOR) && (netlink_pollfd[0].revents & POLLIN) ) { G.iface_exists = check_existence_through_netlink(); if (G.iface_exists < 0) /* error */ goto exiting; if (iface_exists_old != G.iface_exists) { bb_error_msg("interface %sappeared", G.iface_exists ? "" : "dis"); if (G.iface_exists) maybe_up_new_iface(); } } /* note: if !G.iface_exists, returns DOWN */ iface_status = detect_link(); if (iface_status == IFSTATUS_ERR) { if (!(opts & FLAG_MONITOR)) goto exiting; iface_status = IFSTATUS_DOWN; } iface_status_str = strstatus(iface_status); if (iface_status_old != iface_status) { bb_error_msg("link is %s", iface_status_str); if (delay_time) { /* link restored its old status before * we run script. don't run the script: */ delay_time = 0; } else { delay_time = monotonic_sec(); if (iface_status == IFSTATUS_UP) delay_time += G.delay_up; if (iface_status == IFSTATUS_DOWN) delay_time += G.delay_down; if (delay_time == 0) delay_time++; } } if (delay_time && (int)(monotonic_sec() - delay_time) >= 0) { delay_time = 0; if (run_script(iface_status_str) != 0) goto exiting; } } /* while (1) */ cleanup: if (!(opts & FLAG_NO_SHUTDOWN) && (iface_status == IFSTATUS_UP || (iface_status == IFSTATUS_DOWN && delay_time) ) ) { setenv(IFPLUGD_ENV_PREVIOUS, strstatus(iface_status), 1); setenv(IFPLUGD_ENV_CURRENT, strstatus(-1), 1); run_script("down\0up"); /* reusing string */ } exiting: remove_pidfile(pidfile_name); bb_error_msg_and_die("exiting"); }
static void on_ccnet_exit(void) { if (pidfile) remove_pidfile (pidfile); }
static void timeout_handler(const int fd, const short which, void *arg) { struct timeval t = {.tv_sec = 1, .tv_usec = 0}; timeout_t *ptr; unsigned int inmem, outmem, filemem; int i; ptr = (timeout_t *) arg; assert(ptr != NULL); assert(ptr->clockevent.ev_base != NULL); // reset the timer to go off again in 1 second. evtimer_del(&ptr->clockevent); evtimer_set(&ptr->clockevent, timeout_handler, arg); event_base_set(ptr->clockevent.ev_base, &ptr->clockevent); evtimer_add(&ptr->clockevent, &t); assert(fd == INVALID_HANDLE); assert(ptr->server != NULL); assert(ptr->stats != NULL); if (ptr->stats->in_bytes || ptr->stats->out_bytes || ptr->stats->commands || ptr->stats->operations) { inmem=0; outmem=0; filemem = 0; for(i=0; i<ptr->server->maxconns; i++) { if (ptr->server->nodes[i] != NULL) { inmem += ptr->server->nodes[i]->in.length; outmem += ptr->server->nodes[i]->out.length; filemem += ptr->server->nodes[i]->filebuf.length; } } if (inmem > 0) { inmem /= 1024; } if (outmem > 0) { outmem /= 1024; } if (filemem > 0) { filemem /= 1024; } printf("Bytes [%u/%u], Commands [%u], Operations[%u], Mem[%uk/%uk/%uk], Cycles[%u], Undone[%u], RW[%u/%u]\n", ptr->stats->in_bytes, ptr->stats->out_bytes, ptr->stats->commands, ptr->stats->operations, inmem, outmem, filemem, ptr->stats->cycles, ptr->stats->undone, ptr->stats->reads, ptr->stats->writes); ptr->stats->in_bytes = 0; ptr->stats->out_bytes = 0; ptr->stats->commands = 0; ptr->stats->operations = 0; ptr->stats->cycles = 0; ptr->stats->undone = 0; ptr->stats->reads = 0; ptr->stats->writes = 0; } } void timeout_init(timeout_t *ptr, struct event_base *base) { struct timeval t = {.tv_sec = 1, .tv_usec = 0}; assert(ptr != NULL); assert(ptr->clockevent.ev_base == NULL); evtimer_set(&ptr->clockevent, timeout_handler, (void *) ptr); event_base_set(ptr->clockevent.ev_base, &ptr->clockevent); evtimer_add(&ptr->clockevent, &t); assert(ptr->clockevent.ev_base != NULL); } //----------------------------------------------------------------------------- // Main... process command line parameters, and then setup our listening // sockets and event loop. int main(int argc, char **argv) { int c; settings_t *settings = NULL; server_t *server = NULL; timeout_t *timeout = NULL; stats_t *stats = NULL; risp_t *risp = NULL; // handle SIGINT signal(SIGINT, sig_handler); // init settings settings = (settings_t *) malloc(sizeof(settings_t)); assert(settings != NULL); settings_init(settings); // set stderr non-buffering (for running under, say, daemontools) setbuf(stderr, NULL); // process arguments /// Need to check the options in here, there're possibly ones that we dont need. while ((c = getopt(argc, argv, "p:k:c:hvd:u:P:l:s:")) != -1) { switch (c) { case 'p': settings->port = atoi(optarg); assert(settings->port > 0); break; case 'c': settings->maxconns = atoi(optarg); assert(settings->maxconns > 0); break; case 'h': usage(); exit(EXIT_SUCCESS); case 'v': settings->verbose++; break; case 'd': assert(settings->daemonize == false); settings->daemonize = true; break; case 's': assert(settings->storepath == NULL); settings->storepath = optarg; assert(settings->storepath != NULL); assert(settings->storepath[0] != '\0'); break; case 'u': assert(settings->username == NULL); settings->username = optarg; assert(settings->username != NULL); assert(settings->username[0] != '\0'); break; case 'P': assert(settings->pid_file == NULL); settings->pid_file = optarg; assert(settings->pid_file != NULL); assert(settings->pid_file[0] != '\0'); break; case 'l': assert(settings->interface == NULL); settings->interface = strdup(optarg); assert(settings->interface != NULL); assert(settings->interface[0] != '\0'); break; default: fprintf(stderr, "Illegal argument \"%c\"\n", c); return 1; } } if (settings->verbose) printf("Finished processing command-line args\n"); // If needed, increase rlimits to allow as many connections as needed. if (settings->verbose) printf("Settings Max connections: %d\n", settings->maxconns); assert(settings->maxconns > 0); set_maxconns(settings->maxconns); // if we are supplied with a username, drop privs to it. This will only // work if we are running as root, and is really only needed when running as // a daemon. if (settings->username != NULL) { if (settings->verbose) printf("Dropping privs and changing username: '******'\n", settings->username); if (drop_privs(settings->username) != 0) { usage(); exit(EXIT_FAILURE); } } // daemonize if requested // if we want to ensure our ability to dump core, don't chdir to / if (settings->daemonize) { int res; if (settings->verbose) printf("Daemonising\n"); res = daemon(0, settings->verbose); if (res == -1) { fprintf(stderr, "failed to daemon() in order to daemonize\n"); exit(EXIT_FAILURE); } } // initialize main thread libevent instance if (settings->verbose) printf("Initialising the event system.\n"); main_event_base = event_init(); if (settings->verbose) printf("Ignoring SIGPIPE interrupts\n"); ignore_sigpipe(); // save the PID in if we're a daemon, do this after thread_init due to a // file descriptor handling bug somewhere in libevent if (settings->daemonize && settings->pid_file) { if (settings->verbose) printf("Saving Pid file: %s\n", settings->pid_file); save_pid(getpid(), settings->pid_file); } // create and init the 'server' structure. if (settings->verbose) printf("Starting server listener on port %d.\n", settings->port); server = server_new(settings->port, settings->maxconns, settings->interface); if (server == NULL) { fprintf(stderr, "Failed to listen on port %d\n", settings->port); exit(EXIT_FAILURE); } assert(server != NULL); server->verbose = settings->verbose; server->storepath = settings->storepath; // add the server to the event base assert(main_event_base != NULL); server_add_event(server, main_event_base); // initialise clock event. The clock event is used to keep up our node // network. If we dont have enough connections, we will need to make some // requests. // create the timeout structure, and the timeout event. This is used to // perform certain things spread over time. Such as indexing the // 'complete' paths that we have, and ensuring that the 'chunks' parts are // valid. if (settings->verbose) printf("Setting up Timeout event.\n"); timeout = (timeout_t *) malloc(sizeof(timeout_t)); assert(timeout != NULL); assert(main_event_base != NULL); if (settings->verbose) printf("Initialising timeout.\n"); timeout_init(timeout, main_event_base); timeout->server = server; stats = (stats_t *) malloc(sizeof(stats_t)); stats->out_bytes = 0; stats->in_bytes = 0; stats->commands = 0; stats->operations = 0; server->stats = stats; timeout->stats = stats; // Initialise the risp system. risp = risp_init(); assert(risp != NULL); risp_add_invalid(risp, cmdInvalid); risp_add_command(risp, CMD_CLEAR, &cmdClear); risp_add_command(risp, CMD_EXECUTE, &cmdExecute); risp_add_command(risp, CMD_LIST, &cmdList); risp_add_command(risp, CMD_LISTING, &cmdListing); risp_add_command(risp, CMD_LISTING_DONE, &cmdListingDone); risp_add_command(risp, CMD_PUT, &cmdPut); risp_add_command(risp, CMD_GET, &cmdGet); risp_add_command(risp, CMD_SIZE, &cmdSize); risp_add_command(risp, CMD_OFFSET, &cmdOffset); risp_add_command(risp, CMD_FILE, &cmdFile); risp_add_command(risp, CMD_DATA, &cmdData); assert(server->risp == NULL); server->risp = risp; // enter the event loop. if (settings->verbose) printf("Starting Event Loop\n\n"); event_base_loop(main_event_base, 0); // cleanup risp library. risp_shutdown(risp); risp = NULL; // cleanup 'server', which should cleanup all the 'nodes' if (settings->verbose) printf("\n\nExiting.\n"); // remove the PID file if we're a daemon if (settings->daemonize && settings->pid_file != NULL) { if (settings->verbose) printf("Removing pid file: %s\n", settings->pid_file); remove_pidfile(settings->pid_file); } assert(settings != NULL); settings_cleanup(settings); settings = NULL; return 0; }
void main_cleanup(void){ /* cleanup */ frozen_destroy(); remove_pidfile(opt_pidfile); }
int klogd_main(int argc UNUSED_PARAM, char **argv) { int i = 0; char *opt_c; int opt; int used; setup_common_bufsiz(); opt = getopt32(argv, "c:n", &opt_c); if (opt & OPT_LEVEL) { /* Valid levels are between 1 and 8 */ i = xatou_range(opt_c, 1, 8); } if (!(opt & OPT_FOREGROUND)) { bb_daemonize_or_rexec(DAEMON_CHDIR_ROOT, argv); } logmode = LOGMODE_SYSLOG; /* klogd_open() before openlog(), since it might use fixed fd 3, * and openlog() also may use the same fd 3 if we swap them: */ klogd_open(); openlog("kernel", 0, LOG_KERN); /* * glibc problem: for some reason, glibc changes LOG_KERN to LOG_USER * above. The logic behind this is that standard * http://pubs.opengroup.org/onlinepubs/9699919799/functions/syslog.html * says the following about openlog and syslog: * "LOG_USER * Messages generated by arbitrary processes. * This is the default facility identifier if none is specified." * * I believe glibc misinterpreted this text as "if openlog's * third parameter is 0 (=LOG_KERN), treat it as LOG_USER". * Whereas it was meant to say "if *syslog* is called with facility * 0 in its 1st parameter without prior call to openlog, then perform * implicit openlog(LOG_USER)". * * As a result of this, eh, feature, standard klogd was forced * to open-code its own openlog and syslog implementation (!). * * Note that prohibiting openlog(LOG_KERN) on libc level does not * add any security: any process can open a socket to "/dev/log" * and write a string "<0>Voila, a LOG_KERN + LOG_EMERG message" * * Google code search tells me there is no widespread use of * openlog("foo", 0, 0), thus fixing glibc won't break userspace. * * The bug against glibc was filed: * bugzilla.redhat.com/show_bug.cgi?id=547000 */ if (i) klogd_setloglevel(i); signal(SIGHUP, SIG_IGN); /* We want klogd_read to not be restarted, thus _norestart: */ bb_signals_recursive_norestart(BB_FATAL_SIGS, record_signo); syslog(LOG_NOTICE, "klogd started: %s", bb_banner); write_pidfile(CONFIG_PID_FILE_PATH "/klogd.pid"); used = 0; while (!bb_got_signal) { int n; int priority; char *start; /* "2 -- Read from the log." */ start = log_buffer + used; n = klogd_read(start, KLOGD_LOGBUF_SIZE-1 - used); if (n < 0) { if (errno == EINTR) continue; bb_perror_msg(READ_ERROR); break; } start[n] = '\0'; /* Process each newline-terminated line in the buffer */ start = log_buffer; while (1) { char *newline = strchrnul(start, '\n'); if (*newline == '\0') { /* This line is incomplete */ /* move it to the front of the buffer */ overlapping_strcpy(log_buffer, start); used = newline - start; if (used < KLOGD_LOGBUF_SIZE-1) { /* buffer isn't full */ break; } /* buffer is full, log it anyway */ used = 0; newline = NULL; } else { *newline++ = '\0'; } /* Extract the priority */ priority = LOG_INFO; if (*start == '<') { start++; if (*start) priority = strtoul(start, &start, 10); if (*start == '>') start++; } /* Log (only non-empty lines) */ if (*start) syslog(priority, "%s", start); if (!newline) break; start = newline; } } klogd_close(); syslog(LOG_NOTICE, "klogd: exiting"); remove_pidfile(CONFIG_PID_FILE_PATH "/klogd.pid"); if (bb_got_signal) kill_myself_with_sig(bb_got_signal); return EXIT_FAILURE; }
static int mdmon(char *devnm, int must_fork, int takeover) { int mdfd; struct mdinfo *mdi, *di; struct supertype *container; sigset_t set; struct sigaction act; int pfd[2]; int status; int ignore; pid_t victim = -1; int victim_sock = -1; dprintf("starting mdmon for %s\n", devnm); mdfd = open_dev(devnm); if (mdfd < 0) { pr_err("%s: %s\n", devnm, strerror(errno)); return 1; } if (md_get_version(mdfd) < 0) { pr_err("%s: Not an md device\n", devnm); return 1; } /* Fork, and have the child tell us when they are ready */ if (must_fork) { if (pipe(pfd) != 0) { pr_err("failed to create pipe\n"); return 1; } switch(fork()) { case -1: pr_err("failed to fork: %s\n", strerror(errno)); return 1; case 0: /* child */ close(pfd[0]); break; default: /* parent */ close(pfd[1]); if (read(pfd[0], &status, sizeof(status)) != sizeof(status)) { wait(&status); status = WEXITSTATUS(status); } close(pfd[0]); return status; } } else pfd[0] = pfd[1] = -1; container = xcalloc(1, sizeof(*container)); strcpy(container->devnm, devnm); container->arrays = NULL; container->sock = -1; mdi = sysfs_read(mdfd, container->devnm, GET_VERSION|GET_LEVEL|GET_DEVS); if (!mdi) { pr_err("failed to load sysfs info for %s\n", container->devnm); exit(3); } if (mdi->array.level != UnSet) { pr_err("%s is not a container - cannot monitor\n", devnm); exit(3); } if (mdi->array.major_version != -1 || mdi->array.minor_version != -2) { pr_err("%s does not use external metadata - cannot monitor\n", devnm); exit(3); } container->ss = version_to_superswitch(mdi->text_version); if (container->ss == NULL) { pr_err("%s uses unsupported metadata: %s\n", devnm, mdi->text_version); exit(3); } container->devs = NULL; for (di = mdi->devs; di; di = di->next) { struct mdinfo *cd = xmalloc(sizeof(*cd)); *cd = *di; cd->next = container->devs; container->devs = cd; } sysfs_free(mdi); /* SIGUSR is sent between parent and child. So both block it * and enable it only with pselect. */ sigemptyset(&set); sigaddset(&set, SIGUSR1); sigaddset(&set, SIGTERM); sigprocmask(SIG_BLOCK, &set, NULL); act.sa_handler = wake_me; act.sa_flags = 0; sigaction(SIGUSR1, &act, NULL); act.sa_handler = term; sigaction(SIGTERM, &act, NULL); act.sa_handler = SIG_IGN; sigaction(SIGPIPE, &act, NULL); victim = mdmon_pid(container->devnm); if (victim >= 0) victim_sock = connect_monitor(container->devnm); ignore = chdir("/"); if (!takeover && victim > 0 && victim_sock >= 0) { if (fping_monitor(victim_sock) == 0) { pr_err("%s already managed\n", container->devnm); exit(3); } close(victim_sock); victim_sock = -1; } if (container->ss->load_container(container, mdfd, devnm)) { pr_err("Cannot load metadata for %s\n", devnm); exit(3); } close(mdfd); /* Ok, this is close enough. We can say goodbye to our parent now. */ if (victim > 0) remove_pidfile(devnm); if (make_pidfile(devnm) < 0) { exit(3); } container->sock = make_control_sock(devnm); status = 0; if (pfd[1] >= 0) { if (write(pfd[1], &status, sizeof(status)) < 0) pr_err("failed to notify our parent: %d\n", getppid()); close(pfd[1]); } mlockall(MCL_CURRENT | MCL_FUTURE); if (clone_monitor(container) < 0) { pr_err("failed to start monitor process: %s\n", strerror(errno)); exit(2); } if (victim > 0) { try_kill_monitor(victim, container->devnm, victim_sock); if (victim_sock >= 0) close(victim_sock); } setsid(); close(0); open("/dev/null", O_RDWR); close(1); ignore = dup(0); #ifndef DEBUG close(2); ignore = dup(0); #endif /* This silliness is to stop the compiler complaining * that we ignore 'ignore' */ if (ignore) ignore++; do_manager(container); exit(0); }
int suspend ( int fix_rtc ) { FILE *fp = NULL; char buf [64]; time_t alrt, syst, rtct; struct tm alr, sys, rtc; int fd; int rtc_sys_diff; int use_sysfs; if ( !fork_with_pidfile ( )) return 3; // we are the child process from here on ... tzset ( ); // not sure if it is really needed -- it probably doesn't hurt ... time ( &syst );// get the UNIX system time sys = *localtime ( &syst ); use_sysfs = 0; do { if (( fd = open ( "/dev/misc/rtc", O_RDWR )) < 0 ) if (( fd = open ( "/dev/rtc", O_RDWR )) < 0 ) break; // ( 1, "rtc" ); memset ( &rtc, 0, sizeof ( struct tm )); // get the RTC time if ( ioctl ( fd, RTC_RD_TIME, &rtc ) < 0 ) break; // ( 1, "ioctl RTC_RD_TIME" ); rtct = mktime ( &rtc ); rtc_sys_diff = ( syst - rtct ) - sys. tm_gmtoff; // calculate the difference between system and hardware time if ( fix_rtc && (( rtc_sys_diff < -3 ) || ( rtc_sys_diff > 3 ))) { struct tm set; set = *gmtime ( &syst ); // if the difference between system and hardware time is more than 3 seconds, // we have to set the RTC (hwclock --systohc), or alarms won't work reliably. if ( ioctl ( fd, RTC_SET_TIME, &set ) < 0 ) break; // ( 1, "ioctl RTC_SET_TIME" ); } // read the wakeup time from TIMEFILE if (!( fp = fopen ( TIMEFILE, "r" ))) break; // ( 1, TIMEFILE ); if ( !fgets ( buf, sizeof( buf ) - 1, fp )) break; // ( 1, TIMEFILE ); fclose ( fp ); fp = NULL; alrt = atoi ( buf ); // get the alarm time if ( alrt == 0 ) break; // ( 0, TIMEFILE " contains an invalid time description" ); alrt -= 5; // wake up 5 sec before the specified time alr = *gmtime ( &alrt ); if (( fp = fopen ( "/sys/class/rtc/rtc0/alarm/since_epoch", "w" ))) { fprintf ( fp, "%d", mktime( &alr ) ); fclose ( fp ); fp = NULL; if (( fp = fopen ( "/sys/class/rtc/rtc0/alarm/wakeup_enabled", "w" ))) { fprintf ( fp, "1" ); fclose ( fp ); fp = NULL; } else break; use_sysfs = 1; } else { if ( ioctl ( fd, RTC_ALM_SET, &alr ) < 0 ) // set RTC alarm time break; // ( 1, "ioctl RTC_ALM_SET" ); if ( ioctl ( fd, RTC_AIE_ON, 0 ) < 0 ) break; // ( 1, "ioctl RTC_AIE_ON" ); // enable RTC alarm irq } // tell the parent it is safe to exit now .. we have set the RTC alarm kill ( parent_pid, SIGUSR1 ); if ( read ( fd, buf, sizeof( unsigned long )) < 0 ) // wait for the RTC alarm irq break; // ( 1, "read rtc alarm" ); // iPAQ woke up via RTC irq -- otherwise we would have received a SIGUSR2 // from the "resume instance" of opiealarm. if ( use_sysfs ) { if (( fp = fopen ( "/sys/class/rtc/rtc0/alarm/wakeup_enabled", "w" ))) { fprintf ( fp, "0" ); fclose ( fp ); fp = NULL; } } else { if ( ioctl ( fd, RTC_AIE_OFF, 0 ) < 0 ) // disable RTC alarm irq break; // ( 1, "ioctl RTC_AIE_OFF" ); } close ( fd ); fd = -1; remove_pidfile ( ); return 0; } while ( 0 ); if ( fp != NULL ) fclose ( fp ); if ( fd != -1 ) close ( fd ); kill ( parent_pid, SIGUSR1 ); while ( 1 ) // pretend that we are waiting on RTC, so opiealarm -r can kill us sleep ( 1000 ); // if we don't do this, the "resuspend on AC" would be triggerd return 0; }
int main (int argc, char **argv) { int c; conn *l_conn; struct in_addr addr; int lock_memory = 0; int daemonize = 0; int maxcore = 0; char *username = 0; struct passwd *pw; struct sigaction sa; struct rlimit rlim; char *pid_file = NULL; /* init settings */ settings_init(); /* process arguments */ while ((c = getopt(argc, argv, "p:m:Mc:khirvdl:u:P:")) != -1) { switch (c) { case 'p': settings.port = atoi(optarg); break; case 'm': settings.maxbytes = atoi(optarg)*1024*1024; break; case 'M': settings.evict_to_free = 0; break; case 'c': settings.maxconns = atoi(optarg); break; case 'h': usage(); exit(0); case 'i': usage_license(); exit(0); case 'k': lock_memory = 1; break; case 'v': settings.verbose++; break; case 'l': if (!inet_aton(optarg, &addr)) { fprintf(stderr, "Illegal address: %s\n", optarg); return 1; } else { settings.interface = addr; } break; case 'd': daemonize = 1; break; case 'r': maxcore = 1; break; case 'u': username = optarg; break; case 'P': pid_file = optarg; break; default: fprintf(stderr, "Illegal argument \"%c\"\n", c); return 1; } } if (maxcore) { struct rlimit rlim_new; /* * First try raising to infinity; if that fails, try bringing * the soft limit to the hard. */ if (getrlimit(RLIMIT_CORE, &rlim)==0) { rlim_new.rlim_cur = rlim_new.rlim_max = RLIM_INFINITY; if (setrlimit(RLIMIT_CORE, &rlim_new)!=0) { /* failed. try raising just to the old max */ rlim_new.rlim_cur = rlim_new.rlim_max = rlim.rlim_max; (void) setrlimit(RLIMIT_CORE, &rlim_new); } } /* * getrlimit again to see what we ended up with. Only fail if * the soft limit ends up 0, because then no core files will be * created at all. */ if ((getrlimit(RLIMIT_CORE, &rlim)!=0) || rlim.rlim_cur==0) { fprintf(stderr, "failed to ensure corefile creation\n"); exit(1); } } /* * If needed, increase rlimits to allow as many connections * as needed. */ if (getrlimit(RLIMIT_NOFILE, &rlim) != 0) { fprintf(stderr, "failed to getrlimit number of files\n"); exit(1); } else { int maxfiles = settings.maxconns; if (rlim.rlim_cur < maxfiles) rlim.rlim_cur = maxfiles + 3; if (rlim.rlim_max < rlim.rlim_cur) rlim.rlim_max = rlim.rlim_cur; if (setrlimit(RLIMIT_NOFILE, &rlim) != 0) { fprintf(stderr, "failed to set rlimit for open files. Try running as root or requesting smaller maxconns value.\n"); exit(1); } } /* * initialization order: first create the listening socket * (may need root on low ports), then drop root if needed, * then daemonise if needed, then init libevent (in some cases * descriptors created by libevent wouldn't survive forking). */ /* create the listening socket and bind it */ l_socket = server_socket(settings.port); if (l_socket == -1) { fprintf(stderr, "failed to listen\n"); exit(1); } /* lose root privileges if we have them */ if (getuid()== 0 || geteuid()==0) { if (username==0 || *username=='\0') { fprintf(stderr, "can't run as root without the -u switch\n"); return 1; } if ((pw = getpwnam(username)) == 0) { fprintf(stderr, "can't find the user %s to switch to\n", username); return 1; } if (setgid(pw->pw_gid)<0 || setuid(pw->pw_uid)<0) { fprintf(stderr, "failed to assume identity of user %s\n", username); return 1; } } /* daemonize if requested */ /* if we want to ensure our ability to dump core, don't chdir to / */ if (daemonize) { int res; res = daemon(maxcore, settings.verbose); if (res == -1) { fprintf(stderr, "failed to daemon() in order to daemonize\n"); return 1; } } /* initialize other stuff */ item_init(); event_init(); stats_init(); assoc_init(); conn_init(); slabs_init(settings.maxbytes); /* lock paged memory if needed */ if (lock_memory) { #ifdef HAVE_MLOCKALL mlockall(MCL_CURRENT | MCL_FUTURE); #else fprintf(stderr, "warning: mlockall() not supported on this platform. proceeding without.\n"); #endif } /* * ignore SIGPIPE signals; we can use errno==EPIPE if we * need that information */ sa.sa_handler = SIG_IGN; sa.sa_flags = 0; if (sigemptyset(&sa.sa_mask) == -1 || sigaction(SIGPIPE, &sa, 0) == -1) { perror("failed to ignore SIGPIPE; sigaction"); exit(1); } /* create the initial listening connection */ if (!(l_conn = conn_new(l_socket, conn_listening, EV_READ | EV_PERSIST))) { fprintf(stderr, "failed to create listening connection"); exit(1); } /* initialise deletion array and timer event */ deltotal = 200; delcurr = 0; todelete = malloc(sizeof(item *)*deltotal); delete_handler(0,0,0); /* sets up the event */ /* save the PID in if we're a daemon */ if (daemonize) save_pid(getpid(),pid_file); /* enter the loop */ event_loop(0); /* remove the PID file if we're a daemon */ if (daemonize) remove_pidfile(pid_file); return 0; }
int acpid_main(int argc UNUSED_PARAM, char **argv) { int nfd; int opts; struct pollfd *pfd; const char *opt_dir = "/etc/acpi"; const char *opt_input = "/dev/input/event"; const char *opt_logfile = "/var/log/acpid.log"; const char *opt_action = "/etc/acpid.conf"; const char *opt_map = "/etc/acpi.map"; #if ENABLE_FEATURE_PIDFILE const char *opt_pidfile = "/var/run/acpid.pid"; #endif INIT_G(); opt_complementary = "df:e--e"; opts = getopt32(argv, "c:de:fl:a:M:" IF_FEATURE_PIDFILE("p:") IF_FEATURE_ACPID_COMPAT("g:m:s:S:v"), &opt_dir, &opt_input, &opt_logfile, &opt_action, &opt_map IF_FEATURE_PIDFILE(, &opt_pidfile) IF_FEATURE_ACPID_COMPAT(, NULL, NULL, NULL, NULL) ); if (!(opts & OPT_f)) { /* No -f "Foreground", we go to background */ bb_daemonize_or_rexec(DAEMON_CLOSE_EXTRA_FDS, argv); } if (!(opts & OPT_d)) { /* No -d "Debug", we log to log file. * This includes any output from children. */ xmove_fd(xopen(opt_logfile, O_WRONLY | O_CREAT | O_TRUNC), STDOUT_FILENO); xdup2(STDOUT_FILENO, STDERR_FILENO); /* Also, acpid's messages (but not children) will go to syslog too */ openlog(applet_name, LOG_PID, LOG_DAEMON); logmode = LOGMODE_SYSLOG | LOGMODE_STDIO; } /* else: -d "Debug", log is not redirected */ parse_conf_file(opt_action); parse_map_file(opt_map); xchdir(opt_dir); bb_signals((1 << SIGCHLD), SIG_IGN); bb_signals(BB_FATAL_SIGS, record_signo); pfd = NULL; nfd = 0; while (1) { int fd; char *dev_event; dev_event = xasprintf((opts & OPT_e) ? "%s" : "%s%u", opt_input, nfd); fd = open(dev_event, O_RDONLY | O_NONBLOCK); if (fd < 0) { if (nfd == 0) bb_simple_perror_msg_and_die(dev_event); break; } free(dev_event); pfd = xrealloc_vector(pfd, 1, nfd); pfd[nfd].fd = fd; pfd[nfd].events = POLLIN; nfd++; } write_pidfile(opt_pidfile); while (safe_poll(pfd, nfd, -1) > 0) { int i; for (i = 0; i < nfd; i++) { const char *event; if (!(pfd[i].revents & POLLIN)) { if (pfd[i].revents == 0) continue; /* this fd has nothing */ /* Likely POLLERR, POLLHUP, POLLNVAL. * Do not listen on this fd anymore. */ close(pfd[i].fd); nfd--; for (; i < nfd; i++) pfd[i].fd = pfd[i + 1].fd; break; /* do poll() again */ } event = NULL; if (option_mask32 & OPT_e) { char *buf; int len; buf = xmalloc_reads(pfd[i].fd, NULL); /* buf = "button/power PWRB 00000080 00000000" */ len = strlen(buf) - 9; if (len >= 0) buf[len] = '\0'; event = find_action(NULL, buf); free(buf); } else { struct input_event ev; if (sizeof(ev) != full_read(pfd[i].fd, &ev, sizeof(ev))) continue; if (ev.value != 1 && ev.value != 0) continue; event = find_action(&ev, NULL); } if (!event) continue; // spawn event handler process_event(event); } } if (ENABLE_FEATURE_CLEAN_UP) { while (nfd--) close(pfd[nfd].fd); free(pfd); } remove_pidfile(opt_pidfile); return EXIT_SUCCESS; }
int main(int argc, char **argv){ welcome(); init(argc, argv); ServerConfig::max_channels = conf->get_num("front.max_channels"); ServerConfig::max_subscribers_per_channel = conf->get_num("front.max_subscribers_per_channel"); ServerConfig::polling_timeout = conf->get_num("front.polling_timeout"); ServerConfig::channel_buffer_size = conf->get_num("front.channel_buffer_size"); ServerConfig::channel_timeout = 1.5 * ServerConfig::polling_timeout; ServerConfig::polling_idles = ServerConfig::polling_timeout / CHANNEL_CHECK_INTERVAL; ServerConfig::channel_idles = ServerConfig::channel_timeout / CHANNEL_CHECK_INTERVAL; serv = new Server(); ip_filter = new IpFilter(); { // /pub?cid=123&content=hi // /pub?cname=abc&content=hi // content must be json encoded string without leading quote and trailing quote evhttp_set_cb(admin_http, "/pub", pub_handler, NULL); // 分配通道, 返回通道的id和token // /sign?cname=abc&[expires=60] // wait 60 seconds to expire before any sub evhttp_set_cb(admin_http, "/sign", sign_handler, NULL); // 销毁通道 // /close?cname=abc evhttp_set_cb(admin_http, "/close", close_handler, NULL); // 获取通道的信息 // /info?[cname=abc], or TODO: /info?cname=a,b,c evhttp_set_cb(admin_http, "/info", info_handler, NULL); // 判断通道是否处于被订阅状态(所有订阅者断开连接一定时间后, 通道才转为空闲状态) // /check?cname=abc, or TODO: /check?cname=a,b,c evhttp_set_cb(admin_http, "/check", check_handler, NULL); std::string admin_ip; int admin_port = 0; parse_ip_port(conf->get_str("admin.listen"), &admin_ip, &admin_port); struct evhttp_bound_socket *handle; handle = evhttp_bind_socket_with_handle(admin_http, admin_ip.c_str(), admin_port); if(!handle){ log_fatal("bind admin_port %d error! %s", admin_port, strerror(errno)); exit(0); } log_info("admin server listen on %s:%d", admin_ip.c_str(), admin_port); struct evconnlistener *listener = evhttp_bound_socket_get_listener(handle); evconnlistener_set_error_cb(listener, accept_error_cb); // TODO: modify libevent, add evhttp_set_accept_cb() } // init admin ip_filter { Config *cc = (Config *)conf->get("admin"); if(cc != NULL){ std::vector<Config *> *children = &cc->children; std::vector<Config *>::iterator it; for(it = children->begin(); it != children->end(); it++){ if((*it)->key != "allow"){ continue; } const char *ip = (*it)->str(); log_info(" allow %s", ip); ip_filter->add_allow(ip); } } } { Config *cc = (Config *)conf->get("admin"); if(cc != NULL){ std::vector<Config *> *children = &cc->children; std::vector<Config *>::iterator it; for(it = children->begin(); it != children->end(); it++){ if((*it)->key != "deny"){ continue; } const char *ip = (*it)->str(); log_info(" deny %s", ip); ip_filter->add_deny(ip); } } } { // /sub?cid=123&cb=jsonp&token=&seq=123&noop=123 evhttp_set_cb(front_http, "/sub", sub_handler, NULL); // /ping?cb=jsonp evhttp_set_cb(front_http, "/ping", ping_handler, NULL); std::string front_ip; int front_port = 0; parse_ip_port(conf->get_str("front.listen"), &front_ip, &front_port); for(int i=0; i<MAX_BIND_PORTS; i++){ int port = front_port + i; struct evhttp_bound_socket *handle; handle = evhttp_bind_socket_with_handle(front_http, front_ip.c_str(), port); if(!handle){ log_fatal("bind front_port %d error! %s", port, strerror(errno)); exit(0); } log_info("front server listen on %s:%d", front_ip.c_str(), port); struct evconnlistener *listener = evhttp_bound_socket_get_listener(handle); evconnlistener_set_error_cb(listener, accept_error_cb); } std::string auth = conf->get_str("front.auth"); log_info(" auth %s", auth.c_str()); log_info(" max_channels %d", ServerConfig::max_channels); log_info(" max_subscribers_per_channel %d", ServerConfig::max_subscribers_per_channel); log_info(" channel_buffer_size %d", ServerConfig::channel_buffer_size); log_info(" polling_timeout %d", ServerConfig::polling_timeout); if(auth == "token"){ serv->auth = Server::AUTH_TOKEN; } } write_pidfile(); log_info("icomet started"); event_base_dispatch(evbase); event_free(timer_event); event_free(sigint_event); event_free(sigterm_event); evhttp_free(admin_http); evhttp_free(front_http); event_base_free(evbase); delete serv; delete conf; delete ip_filter; remove_pidfile(); log_info("icomet exit"); return 0; }
static void setup(void) { char *fname = NULL; uint64_t intvl; if (atexit(teardown) != 0) { log_stderr("cannot register teardown procedure with atexit()"); exit(EX_OSERR); /* only failure comes from NOMEM */ } /* Setup logging first */ log_setup(&stats.log); if (debug_setup(&setting.debug) != CC_OK) { log_stderr("debug log setup failed"); exit(EX_CONFIG); } /* setup top-level application options */ if (option_bool(&setting.ds.daemonize)) { daemonize(); } fname = option_str(&setting.ds.pid_filename); if (fname != NULL) { /* to get the correct pid, call create_pidfile after daemonize */ create_pidfile(fname); } /* setup library modules */ buf_setup(&setting.buf, &stats.buf); dbuf_setup(&setting.dbuf, &stats.dbuf); event_setup(&stats.event); sockio_setup(&setting.sockio, &stats.sockio); tcp_setup(&setting.tcp, &stats.tcp); timing_wheel_setup(&stats.timing_wheel); /* setup pelikan modules */ time_setup(&setting.time); procinfo_setup(&stats.procinfo); request_setup(&setting.request, &stats.request); response_setup(&setting.response, &stats.response); parse_setup(&stats.parse_req, NULL); compose_setup(NULL, &stats.compose_rsp); slab_setup(&setting.slab, &stats.slab); process_setup(&setting.process, &stats.process); admin_process_setup(); core_admin_setup(&setting.admin); core_server_setup(&setting.server, &stats.server); core_worker_setup(&setting.worker, &stats.worker); /* adding recurring events to maintenance/admin thread */ intvl = option_uint(&setting.ds.dlog_intvl); if (core_admin_register(intvl, debug_log_flush, NULL) == NULL) { log_stderr("Could not register timed event to flush debug log"); goto error; } return; error: if (fname != NULL) { remove_pidfile(fname); } /* since we registered teardown with atexit, it'll be called upon exit */ exit(EX_CONFIG); }
int udhcpd_main(int argc, char **argv) { fd_set rfds; struct timeval tv; int server_socket = -1, bytes, retval, max_sock; struct dhcpMessage packet; uint8_t *state, *server_id, *requested; uint32_t server_id_align, requested_align, static_lease_ip; unsigned timeout_end; unsigned num_ips; unsigned opt; struct option_set *option; struct dhcpOfferedAddr *lease, static_lease; opt = getopt32(argv, "fS"); argv += optind; if (!(opt & 1)) { /* no -f */ bb_daemonize_or_rexec(0, argv); logmode &= ~LOGMODE_STDIO; } if (opt & 2) { /* -S */ openlog(applet_name, LOG_PID, LOG_LOCAL0); logmode |= LOGMODE_SYSLOG; } /* Would rather not do read_config before daemonization - * otherwise NOMMU machines will parse config twice */ read_config(argv[0] ? argv[0] : DHCPD_CONF_FILE); /* Make sure fd 0,1,2 are open */ bb_sanitize_stdio(); /* Equivalent of doing a fflush after every \n */ setlinebuf(stdout); /* Create pidfile */ write_pidfile(server_config.pidfile); /* if (!..) bb_perror_msg("cannot create pidfile %s", pidfile); */ bb_info_msg("%s (v"BB_VER") started", applet_name); option = find_option(server_config.options, DHCP_LEASE_TIME); server_config.lease = LEASE_TIME; if (option) { memcpy(&server_config.lease, option->data + 2, 4); server_config.lease = ntohl(server_config.lease); } /* Sanity check */ num_ips = server_config.end_ip - server_config.start_ip + 1; if (server_config.max_leases > num_ips) { bb_error_msg("max_leases=%u is too big, setting to %u", (unsigned)server_config.max_leases, num_ips); server_config.max_leases = num_ips; } leases = xzalloc(server_config.max_leases * sizeof(*leases)); read_leases(server_config.lease_file); if (read_interface(server_config.interface, &server_config.ifindex, &server_config.server, server_config.arp)) { retval = 1; goto ret; } /* Setup the signal pipe */ udhcp_sp_setup(); timeout_end = monotonic_sec() + server_config.auto_time; while (1) { /* loop until universe collapses */ if (server_socket < 0) { server_socket = listen_socket(/*INADDR_ANY,*/ SERVER_PORT, server_config.interface); } max_sock = udhcp_sp_fd_set(&rfds, server_socket); if (server_config.auto_time) { tv.tv_sec = timeout_end - monotonic_sec(); tv.tv_usec = 0; } retval = 0; if (!server_config.auto_time || tv.tv_sec > 0) { retval = select(max_sock + 1, &rfds, NULL, NULL, server_config.auto_time ? &tv : NULL); } if (retval == 0) { write_leases(); timeout_end = monotonic_sec() + server_config.auto_time; continue; } if (retval < 0 && errno != EINTR) { DEBUG("error on select"); continue; } switch (udhcp_sp_read(&rfds)) { case SIGUSR1: bb_info_msg("Received a SIGUSR1"); write_leases(); /* why not just reset the timeout, eh */ timeout_end = monotonic_sec() + server_config.auto_time; continue; case SIGTERM: bb_info_msg("Received a SIGTERM"); goto ret0; case 0: break; /* no signal */ default: continue; /* signal or error (probably EINTR) */ } bytes = udhcp_recv_packet(&packet, server_socket); /* this waits for a packet - idle */ if (bytes < 0) { if (bytes == -1 && errno != EINTR) { DEBUG("error on read, %s, reopening socket", strerror(errno)); close(server_socket); server_socket = -1; } continue; } state = get_option(&packet, DHCP_MESSAGE_TYPE); if (state == NULL) { bb_error_msg("cannot get option from packet, ignoring"); continue; } /* Look for a static lease */ static_lease_ip = getIpByMac(server_config.static_leases, &packet.chaddr); if (static_lease_ip) { bb_info_msg("Found static lease: %x", static_lease_ip); memcpy(&static_lease.chaddr, &packet.chaddr, 16); static_lease.yiaddr = static_lease_ip; static_lease.expires = 0; lease = &static_lease; } else { lease = find_lease_by_chaddr(packet.chaddr); } switch (state[0]) { case DHCPDISCOVER: DEBUG("Received DISCOVER"); if (sendOffer(&packet) < 0) { bb_error_msg("send OFFER failed"); } /* circle test Stat. add by wangpu begin */ g_offercount ++; printf("Circle test: [DHCPS] send OFFER packet num:[%d]\n",g_offercount); memset(g_acCmd,0,sizeof(g_acCmd)); memset(g_interface,0,sizeof(g_interface)); sprintf(g_interface,"%s",server_config.interface); sprintf(g_acCmd,"echo %d > /var/circle/%s",g_offercount,g_interface); system(g_acCmd); /* circle test Stat. add by wangpu end */ break; case DHCPREQUEST: DEBUG("received REQUEST"); #if 0 /* ?¡¤??2a¨º? add by wangpu begin */ g_offercount ++; printf("Circle test: [DHCPS] send OFFER packet num:[%d]\n",g_offercount); memset(g_acCmd,0,sizeof(g_acCmd)); memset(g_interface,0,sizeof(g_interface)); sprintf(g_interface,"%s",server_config.interface); sprintf(g_acCmd,"echo %d > /var/circle/%s",g_offercount,g_interface); system(g_acCmd); /* ?¡¤??2a¨º? add by wangpu begin */ #endif requested = get_option(&packet, DHCP_REQUESTED_IP); server_id = get_option(&packet, DHCP_SERVER_ID); if (requested) memcpy(&requested_align, requested, 4); if (server_id) memcpy(&server_id_align, server_id, 4); if (lease) { if (server_id) { /* SELECTING State */ DEBUG("server_id = %08x", ntohl(server_id_align)); if (server_id_align == server_config.server && requested && requested_align == lease->yiaddr ) { sendACK(&packet, lease->yiaddr); } } else if (requested) { /* INIT-REBOOT State */ if (lease->yiaddr == requested_align) sendACK(&packet, lease->yiaddr); else sendNAK(&packet); } else if (lease->yiaddr == packet.ciaddr) { /* RENEWING or REBINDING State */ sendACK(&packet, lease->yiaddr); } else { /* don't know what to do!!!! */ sendNAK(&packet); } /* what to do if we have no record of the client */ } else if (server_id) { /* SELECTING State */ } else if (requested) { /* INIT-REBOOT State */ lease = find_lease_by_yiaddr(requested_align); if (lease) { if (lease_expired(lease)) { /* probably best if we drop this lease */ memset(lease->chaddr, 0, 16); /* make some contention for this address */ } else sendNAK(&packet); } else { uint32_t r = ntohl(requested_align); if (r < server_config.start_ip || r > server_config.end_ip ) { sendNAK(&packet); } /* else remain silent */ } } else { /* RENEWING or REBINDING State */ } break; case DHCPDECLINE: DEBUG("Received DECLINE"); if (lease) { memset(lease->chaddr, 0, 16); lease->expires = time(0) + server_config.decline_time; } break; case DHCPRELEASE: DEBUG("Received RELEASE"); if (lease) lease->expires = time(0); break; case DHCPINFORM: DEBUG("Received INFORM"); send_inform(&packet); break; default: bb_info_msg("Unsupported DHCP message (%02x) - ignoring", state[0]); } } ret0: retval = 0; ret: /*if (server_config.pidfile) - server_config.pidfile is never NULL */ remove_pidfile(server_config.pidfile); return retval; }
/*---------------------------------------------------------------------------*/ int main(int argc, char *const argv[]) { struct xio_server *server; /* server portal */ char url[256]; int i; struct sigaction sa; int c; char *addr = NULL; char *port = NULL; char *trans = NULL; while (1) { c = getopt_long(argc, argv, "a:p:r:hdnV", longopts, NULL); if (c == -1) break; switch (c) { case 'a': addr = optarg; break; case 'p': port = optarg; break; case 'r': trans = optarg; break; case 'h': usage(argv[0], 0); case 'd': debug_flag++; nofork_flag++; break; case 'n': nofork_flag++; break; case 'V': printf("%s\n", PACKAGE_STRING); exit(0); break; default: usage(argv[0], 1); break; } } memset(&sa, 0, sizeof(sa)); sa.sa_handler = signal_handler; sigaction(SIGINT, &sa, NULL); sigaction(SIGTERM, &sa, NULL); sigaction(SIGQUIT, &sa, NULL); sigaction(SIGHUP, &sa, NULL); sa.sa_handler = SIG_IGN; sa.sa_flags = SA_RESTART; sigaction(SIGPIPE, &sa, NULL); if (!nofork_flag && daemon(0, 0)) { logerr("daemon() failed"); exit(1); } if (!debug_flag) { openlog("xiosrvd", LOG_PID, LOG_DAEMON); use_syslog = 1; } /* Create the process PID file */ if (create_pidfile(pid_file) != 0) exit(EXIT_FAILURE); /* initialize library */ xio_init(); /* create "hello world" message */ memset(&server_data, 0, sizeof(server_data)); for (i = 0; i < QUEUE_DEPTH; i++) { server_data.rsp[i].out.header.iov_base = strdup("hello world header response"); server_data.rsp[i].out.header.iov_len = strlen((const char *) server_data.rsp[i].out.header.iov_base) + 1; } /* create thread context for the client */ server_data.ctx = xio_context_create(NULL, 0, -1); /* create url to connect to */ if (trans) sprintf(url, "%s://%s:%s", trans, addr, port); else sprintf(url, "rdma://%s:%s", addr, port); reload: /* bind a listener server to a portal/url */ server = xio_bind(server_data.ctx, &server_ops, url, NULL, 0, &server_data); if (server) { logit(LOG_INFO, "listen to %s", url); xio_context_run_loop(server_data.ctx, XIO_INFINITE); /* free the server */ xio_unbind(server); if (reload_flag) { reload_flag = 0; goto reload; } /* normal exit phase */ logit(LOG_INFO, "exit signaled"); } /* free the message */ for (i = 0; i < QUEUE_DEPTH; i++) free(server_data.rsp[i].out.header.iov_base); /* free the context */ xio_context_destroy(server_data.ctx); xio_shutdown(); remove_pidfile(); if (use_syslog) closelog(); return 0; }
static void remove_pidfile_on_signal(int signo) { remove_pidfile(); sigchain_pop(signo); raise(signo); }
static void cleanup() { remove_pidfile(G.pidfile); }