int
main(int argc, char **argv)
{
krb5_error_code ret;
krb5_context context;
krb5_kdc_configuration *config;
int optidx = 0;
setprogname(argv[0]);
ret = krb5_init_context(&context);
if (ret == KRB5_CONFIG_BADFORMAT)
errx (1, "krb5_init_context failed to parse configuration file");
else if (ret)
errx (1, "krb5_init_context failed: %d", ret);
ret = krb5_kt_register(context, &hdb_get_kt_ops);
if (ret)
errx (1, "krb5_kt_register(HDB) failed: %d", ret);
config = configure(context, argc, argv, &optidx);
#ifdef HAVE_SIGACTION
{
struct sigaction sa;
sa.sa_flags = 0;
sa.sa_handler = sigterm;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
#ifdef SIGXCPU
sigaction(SIGXCPU, &sa, NULL);
#endif
sa.sa_handler = SIG_IGN;
#ifdef SIGPIPE
sigaction(SIGPIPE, &sa, NULL);
#endif
}
#else
signal(SIGINT, sigterm);
signal(SIGTERM, sigterm);
#ifdef SIGXCPU
signal(SIGXCPU, sigterm);
#endif
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
#endif
#ifdef __APPLE__
bonjour_announce(context, config);
#endif
pidfile(NULL);
switch_environment();
loop(context, config);
krb5_free_context(context);
return 0;
}
int main(int argc, char *argv[])
{
int timeout = WDT_TIMEOUT_DEFAULT;
int real_timeout = 0;
int T;
int background = 1;
int use_syslog = 1;
int c, status;
int log_opts = LOG_NDELAY | LOG_NOWAIT | LOG_PID;
struct option long_options[] = {
{"load-average", 1, 0, 'a'},
{"foreground", 0, 0, 'n'},
{"help", 0, 0, 'h'},
{"interval", 1, 0, 't'},
{"loglevel", 1, 0, 'l'},
{"meminfo", 1, 0, 'm'},
{"filenr", 1, 0, 'f'},
{"pmon", 2, 0, 'p'},
{"safe-exit", 0, 0, 'e'},
{"syslog", 0, 0, 's'},
#ifndef TESTMODE_DISABLED
{"test-mode", 0, 0, 'S'}, /* Hidden test mode, not for public use. */
#endif
{"version", 0, 0, 'v'},
{"timeout", 1, 0, 'T'},
{NULL, 0, 0, 0}
};
uev_ctx_t ctx;
while ((c = getopt_long(argc, argv, "a:f:Fhl:Lm:np::sSt:T:Vvx?", long_options, NULL)) != EOF) {
switch (c) {
case 'a':
if (loadavg_set(optarg))
return usage(1);
break;
case 'f':
if (filenr_set(optarg))
return usage(1);
break;
case 'h':
return usage(0);
case 'l':
loglevel = __wdog_loglevel(optarg);
if (-1 == loglevel)
return usage(1);
break;
case 'm':
if (meminfo_set(optarg))
return usage(1);
break;
case 'F': /* BusyBox watchdogd compat. */
case 'n': /* Run in foreground */
background = 0;
use_syslog--;
break;
case 'p':
if (pmon_set(optarg))
return usage(1);
break;
case 's':
use_syslog++;
break;
#ifndef TESTMODE_DISABLED
case 'S': /* Simulate: no interaction with kernel, for testing pmon */
__wdt_testmode = 1;
break;
#endif
case 't': /* Watchdog kick interval */
if (!optarg) {
ERROR("Missing interval argument.");
return usage(1);
}
period = atoi(optarg);
break;
case 'T': /* Watchdog timeout */
if (!optarg) {
ERROR("Missing timeout argument.");
return usage(1);
}
timeout = atoi(optarg);
break;
case 'v':
printf("v%s\n", VERSION);
return 0;
case 'x': /* Safe exit, i.e., don't reboot if we exit and close device */
magic = 1;
break;
default:
printf("Unrecognized option \"-%c\".\n", c);
return usage(1);
}
}
/* BusyBox watchdogd compat. */
if (optind < argc) {
char *dev = argv[optind];
if (!strncmp(dev, "/dev", 4))
strlcpy(devnode, dev, sizeof(devnode));
}
if (background) {
DEBUG("Daemonizing ...");
if (-1 == daemon(0, 0)) {
PERROR("Failed daemonizing");
return 1;
}
}
if (!background && use_syslog < 1)
log_opts |= LOG_PERROR;
setlogmask(LOG_UPTO(loglevel));
openlog(NULL, log_opts, LOG_DAEMON);
INFO("watchdogd v%s %s ...", PACKAGE_VERSION, wdt_testmode() ? "test mode" : "starting");
uev_init(&ctx);
/* Setup callbacks for SIGUSR1 and, optionally, exit magic on SIGINT/SIGTERM */
setup_signals(&ctx);
if (wdt_init()) {
PERROR("Failed connecting to kernel watchdog driver");
return 1;
}
/* Set requested WDT timeout right before we enter the event loop. */
if (wdt_set_timeout(timeout))
PERROR("Failed setting HW watchdog timeout: %d", timeout);
/* Sanity check with driver that setting actually took. */
real_timeout = wdt_get_timeout();
if (real_timeout < 0) {
PERROR("Failed reading current watchdog timeout");
} else {
if (real_timeout <= period) {
ERROR("Warning, watchdog timeout <= kick interval: %d <= %d",
real_timeout, period);
}
}
/* If user did not provide '-k' argument, set to half actual timeout */
if (-1 == period) {
if (real_timeout < 0)
period = WDT_KICK_DEFAULT;
else
period = real_timeout / 2;
if (!period)
period = 1;
}
/* Calculate period (T) in milliseconds for libuEv */
T = period * 1000;
DEBUG("Watchdog kick interval set to %d sec.", period);
/* Read boot cause from watchdog and save in /var/run/watchdogd.status */
create_bootstatus(real_timeout, period);
/* Every period (T) seconds we kick the wdt */
uev_timer_init(&ctx, &period_watcher, period_cb, NULL, T, T);
/* Start all enabled plugins */
wdt_plugins_init(&ctx, T);
/* Only create pidfile when we're done with all set up. */
if (pidfile(NULL) && !wdt_testmode())
PERROR("Cannot create pidfile");
status = uev_run(&ctx, 0);
if (wdt_testmode())
return status;
while (wait_reboot) {
int reboot_in = 3 * real_timeout;
INFO("Waiting for HW WDT reboot ...");
while (reboot_in > 0) {
unsigned int rest = sleep(real_timeout);
while (rest)
rest = sleep(rest);
reboot_in -= real_timeout;
}
INFO("HW WDT dit not reboot, forcing reboot now ...");
reboot(RB_AUTOBOOT);
}
return status;
}
int
main(int argc, char **argv)
{
int ch, np, ret, Xflag = 0;
pcap_handler phandler = dump_packet;
const char *errstr = NULL;
char *pidf = NULL;
ret = 0;
closefrom(STDERR_FILENO + 1);
while ((ch = getopt(argc, argv, "Dxd:f:i:p:s:")) != -1) {
switch (ch) {
case 'D':
Debug = 1;
break;
case 'd':
delay = strtonum(optarg, 5, 60*60, &errstr);
if (errstr)
usage();
break;
case 'f':
filename = optarg;
break;
case 'i':
interface = optarg;
break;
case 'p':
pidf = optarg;
break;
case 's':
snaplen = strtonum(optarg, 0, PFLOGD_MAXSNAPLEN,
&errstr);
if (snaplen <= 0)
snaplen = DEF_SNAPLEN;
if (errstr)
snaplen = PFLOGD_MAXSNAPLEN;
break;
case 'x':
Xflag++;
break;
default:
usage();
}
}
log_debug = Debug;
argc -= optind;
argv += optind;
/* does interface exist */
if (!if_exists(interface)) {
warn("Failed to initialize: %s", interface);
logmsg(LOG_ERR, "Failed to initialize: %s", interface);
logmsg(LOG_ERR, "Exiting, init failure");
exit(1);
}
if (!Debug) {
openlog("pflogd", LOG_PID | LOG_CONS, LOG_DAEMON);
if (daemon(0, 0)) {
logmsg(LOG_WARNING, "Failed to become daemon: %s",
strerror(errno));
}
pidfile(pidf);
}
tzset();
(void)umask(S_IRWXG | S_IRWXO);
/* filter will be used by the privileged process */
if (argc) {
filter = copy_argv(argv);
if (filter == NULL)
logmsg(LOG_NOTICE, "Failed to form filter expression");
}
/* initialize pcap before dropping privileges */
if (init_pcap()) {
logmsg(LOG_ERR, "Exiting, init failure");
exit(1);
}
/* Privilege separation begins here */
if (priv_init()) {
logmsg(LOG_ERR, "unable to privsep");
exit(1);
}
setproctitle("[initializing]");
/* Process is now unprivileged and inside a chroot */
signal(SIGTERM, sig_close);
signal(SIGINT, sig_close);
signal(SIGQUIT, sig_close);
signal(SIGALRM, sig_alrm);
signal(SIGUSR1, sig_usr1);
signal(SIGHUP, sig_hup);
alarm(delay);
buffer = malloc(PFLOGD_BUFSIZE);
if (buffer == NULL) {
logmsg(LOG_WARNING, "Failed to allocate output buffer");
phandler = dump_packet_nobuf;
} else {
bufleft = buflen = PFLOGD_BUFSIZE;
bufpos = buffer;
bufpkt = 0;
}
if (reset_dump(Xflag) < 0) {
if (Xflag)
return (1);
logmsg(LOG_ERR, "Logging suspended: open error");
set_suspended(1);
} else if (Xflag)
return (0);
while (1) {
np = pcap_dispatch(hpcap, PCAP_NUM_PKTS,
phandler, (u_char *)dpcap);
if (np < 0) {
if (!if_exists(interface) == -1) {
logmsg(LOG_NOTICE, "interface %s went away",
interface);
ret = -1;
break;
}
logmsg(LOG_NOTICE, "%s", pcap_geterr(hpcap));
}
if (gotsig_close)
break;
if (gotsig_hup) {
if (reset_dump(0)) {
logmsg(LOG_ERR,
"Logging suspended: open error");
set_suspended(1);
}
gotsig_hup = 0;
}
if (gotsig_alrm) {
if (dpcap)
flush_buffer(dpcap);
else
gotsig_hup = 1;
gotsig_alrm = 0;
alarm(delay);
}
if (gotsig_usr1) {
log_pcap_stats();
gotsig_usr1 = 0;
}
}
logmsg(LOG_NOTICE, "Exiting");
if (dpcap) {
flush_buffer(dpcap);
fclose(dpcap);
}
purge_buffer();
log_pcap_stats();
pcap_close(hpcap);
if (!Debug)
closelog();
return (ret);
}
int main(int argc, char *argv[])
{
int dummy, dummysigalrm, foreground = 0;
struct timeval tv, difftime, curtime, lasttime, *timeout;
fd_set rfds, readers;
int nfds, n, i, secs, ch;
struct sigaction sa;
time_t boottime;
struct option long_options[] = {
{"config", 1, 0, 'c'},
{"debug", 2, 0, 'd'},
{"foreground", 0, 0, 'f'},
{"disable-vifs", 0, 0, 'N'},
{"help", 0, 0, 'h'},
{"version", 0, 0, 'v'},
{0, 0, 0, 0}
};
snprintf(versionstring, sizeof (versionstring), "pimd version %s", todaysversion);
while ((ch = getopt_long (argc, argv, "c:d::fhNP::v", long_options, NULL)) != EOF) {
switch (ch) {
case 'c':
configfilename = optarg;
break;
case 'd':
if (!optarg) {
debug = DEBUG_DEFAULT;
} else {
char *p,*q;
size_t i, len;
struct debugname *d;
debug = 0;
p = optarg; q = NULL;
while (p) {
q = strchr(p, ',');
if (q)
*q++ = '\0';
len = strlen(p);
for (i = 0, d = debugnames; i < ARRAY_LEN(debugnames); i++, d++)
if (len >= d->nchars && strncmp(d->name, p, len) == 0)
break;
if (i == ARRAY_LEN(debugnames))
return usage();
debug |= d->level;
p = q;
}
}
break;
case 'f':
foreground = 1;
break;
case 'h':
return usage();
case 'N':
disable_all_by_default = 1;
break;
case 'P':
#ifdef SNMP
if (!optarg)
dest_port = DEFAULT_PORT;
else {
dest_port = strtonum(optarg, 1, 65535, &errstr);
if (errstr) {
warnx("destination port %s", errstr);
dest_port = DEFAULT_PORT;
}
}
#else
warnx("SNMP support missing, please feel free to submit a patch.");
#endif
break;
case 'v':
printf("%s\n", versionstring);
return 0;
default:
return usage();
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
return usage();
}
if (geteuid() != 0) {
fprintf(stderr, "%s: must be root\n", __progname);
exit(1);
}
setlinebuf(stderr);
if (debug != 0) {
struct debugname *d;
char c;
int tmpd = debug;
fprintf(stderr, "debug level 0x%lx ", debug);
c = '(';
for (d = debugnames; d < debugnames + ARRAY_LEN(debugnames); d++) {
if ((tmpd & d->level) == d->level) {
tmpd &= ~d->level;
fprintf(stderr, "%c%s", c, d->name);
c = ',';
}
}
fprintf(stderr, ")\n");
}
#ifdef LOG_DAEMON
(void)openlog("pimd", LOG_PID, LOG_DAEMON);
(void)setlogmask(LOG_UPTO(LOG_NOTICE));
#else
(void)openlog("pimd", LOG_PID);
#endif /* LOG_DAEMON */
logit(LOG_DEBUG, 0, "%s starting", versionstring);
/* TODO: XXX: use a combination of time and hostid to initialize the random
* generator.
*/
#ifdef SYSV
srand48(time(NULL));
#else
srandom(gethostid());
#endif
time(&boottime);
/* Start up the log rate-limiter */
resetlogging(NULL);
callout_init();
init_igmp();
init_pim();
#ifdef HAVE_ROUTING_SOCKETS
init_routesock();
#endif /* HAVE_ROUTING_SOCKETS */
init_pim_mrt();
init_timers();
/* TODO: check the kernel DVMRP/MROUTED/PIM support version */
#ifdef SNMP
if (i = snmp_init())
return i;
#endif /* SNMP */
init_vifs();
init_rp_and_bsr(); /* Must be after init_vifs() */
#ifdef RSRR
rsrr_init();
#endif /* RSRR */
sa.sa_handler = handler;
sa.sa_flags = 0; /* Interrupt system calls */
sigemptyset(&sa.sa_mask);
sigaction(SIGALRM, &sa, NULL);
sigaction(SIGHUP, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
sigaction(SIGUSR1, &sa, NULL);
sigaction(SIGUSR2, &sa, NULL);
FD_ZERO(&readers);
FD_SET(igmp_socket, &readers);
nfds = igmp_socket + 1;
for (i = 0; i < nhandlers; i++) {
FD_SET(ihandlers[i].fd, &readers);
if (ihandlers[i].fd >= nfds)
nfds = ihandlers[i].fd + 1;
}
IF_DEBUG(DEBUG_IF)
dump_vifs(stderr);
IF_DEBUG(DEBUG_PIM_MRT)
dump_pim_mrt(stderr);
/* schedule first timer interrupt */
timer_setTimer(TIMER_INTERVAL, timer, NULL);
if (!debug && !foreground) {
/* Detach from the terminal */
haveterminal = 0;
if (fork())
exit(0);
(void)close(0);
(void)close(1);
(void)close(2);
(void)open("/", 0);
(void)dup2(0, 1);
(void)dup2(0, 2);
#if defined(SYSV) || defined(__USE_SVID)
(void)setpgrp();
#else
#ifdef TIOCNOTTY
n = open("/dev/tty", 2);
if (n >= 0) {
(void)ioctl(n, TIOCNOTTY, (char *)0);
(void)close(n);
}
#else
if (setsid() < 0)
perror("setsid");
#endif /* TIOCNOTTY */
#endif /* SYSV */
} /* End of child process code */
if (pidfile (NULL)) {
warn("Cannot create pidfile");
}
/*
* Main receive loop.
*/
dummy = 0;
dummysigalrm = SIGALRM;
difftime.tv_usec = 0;
gettimeofday(&curtime, NULL);
lasttime = curtime;
while (1) {
bcopy((char *)&readers, (char *)&rfds, sizeof(rfds));
secs = timer_nextTimer();
if (secs == -1)
timeout = NULL;
else {
timeout = &tv;
timeout->tv_sec = secs;
timeout->tv_usec = 0;
}
if (boottime) {
time_t n;
time(&n);
if (n > boottime + 15) {
struct rp_hold *rph = g_rp_hold;
while(rph) {
add_rp_grp_entry(&cand_rp_list, &grp_mask_list,
rph->address, 1, (u_int16)0xffffff, rph->group, rph->mask,
curr_bsr_hash_mask, curr_bsr_fragment_tag);
rph = rph->next;
}
boottime = 0;
}
}
if (sighandled) {
if (sighandled & GOT_SIGINT) {
sighandled &= ~GOT_SIGINT;
break;
}
if (sighandled & GOT_SIGHUP) {
sighandled &= ~GOT_SIGHUP;
restart(SIGHUP);
/* reconstruct readers and nfds */
FD_ZERO(&readers);
FD_SET(igmp_socket, &readers);
nfds = igmp_socket + 1;
for (i = 0; i < nhandlers; i++) {
FD_SET(ihandlers[i].fd, &readers);
if (ihandlers[i].fd >= nfds)
nfds = ihandlers[i].fd + 1;
}
bcopy((char *)&readers, (char *)&rfds, sizeof(rfds));
}
if (sighandled & GOT_SIGUSR1) {
sighandled &= ~GOT_SIGUSR1;
fdump(SIGUSR1);
}
if (sighandled & GOT_SIGUSR2) {
sighandled &= ~GOT_SIGUSR2;
cdump(SIGUSR2);
}
if (sighandled & GOT_SIGALRM) {
sighandled &= ~GOT_SIGALRM;
timer(&dummysigalrm);
}
}
if ((n = select(nfds, &rfds, NULL, NULL, timeout)) < 0) {
if (errno != EINTR) /* SIGALRM is expected */
logit(LOG_WARNING, errno, "select failed");
continue;
}
if (n > 0) {
/* TODO: shall check first igmp_socket for better performance? */
for (i = 0; i < nhandlers; i++) {
if (FD_ISSET(ihandlers[i].fd, &rfds)) {
(*ihandlers[i].func)(ihandlers[i].fd, &rfds);
}
}
}
/*
* Handle timeout queue.
*
* If select + packet processing took more than 1 second,
* or if there is a timeout pending, age the timeout queue.
*
* If not, collect usec in difftime to make sure that the
* time doesn't drift too badly.
*
* If the timeout handlers took more than 1 second,
* age the timeout queue again. XXX This introduces the
* potential for infinite loops!
*/
do {
/*
* If the select timed out, then there's no other
* activity to account for and we don't need to
* call gettimeofday.
*/
if (n == 0) {
curtime.tv_sec = lasttime.tv_sec + secs;
curtime.tv_usec = lasttime.tv_usec;
n = -1; /* don't do this next time through the loop */
} else
gettimeofday(&curtime, NULL);
difftime.tv_sec = curtime.tv_sec - lasttime.tv_sec;
difftime.tv_usec += curtime.tv_usec - lasttime.tv_usec;
while (difftime.tv_usec >= 1000000) {
difftime.tv_sec++;
difftime.tv_usec -= 1000000;
}
if (difftime.tv_usec < 0) {
difftime.tv_sec--;
difftime.tv_usec += 1000000;
}
lasttime = curtime;
if (secs == 0 || difftime.tv_sec > 0)
age_callout_queue(difftime.tv_sec);
secs = -1;
} while (difftime.tv_sec > 0);
} /* Main loop */
logit(LOG_NOTICE, 0, "%s exiting", versionstring);
cleanup();
exit(0);
}
int
main(int argc, char **argv)
{
int i, c, maxfd, rval, qpsock, fd;
fd_set fds, rfds;
FILE *fp, *client[MAX_CLIENT];
m_debug = 0;
l_debug = LOG_INFO;
fp = NULL;
for (i = 0; i < MAX_CLIENT; i++)
client[i] = NULL;
while ((c = getopt(argc, argv, "f:vdl:")) != -1) {
switch (c) {
case 'f':
altqconfigfile = optarg;
break;
case 'v':
l_debug = LOG_DEBUG;
m_debug |= DEBUG_ALTQ;
daemonize = 0;
break;
case 'd':
daemonize = 0;
break;
case 'l':
l_debug = atoi(optarg);
break;
default:
usage();
}
}
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
signal(SIGHUP, sig_handler);
signal(SIGPIPE, sig_handler);
if (daemonize)
openlog("altqd", LOG_PID, LOG_DAEMON);
if (qcmd_init() != 0) {
if (daemonize)
closelog();
exit(1);
}
/*
* open a unix domain socket for altqd clients
*/
if ((qpsock = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0)
LOG(LOG_ERR, errno, "can't open unix domain socket");
else {
struct sockaddr_un addr;
bzero(&addr, sizeof(addr));
addr.sun_family = AF_LOCAL;
strlcpy(addr.sun_path, QUIP_PATH, sizeof(addr.sun_path));
unlink(QUIP_PATH);
if (bind(qpsock, (struct sockaddr *)&addr,
sizeof(addr)) < 0) {
LOG(LOG_ERR, errno, "can't bind to %s", QUIP_PATH);
close(qpsock);
qpsock = -1;
}
chmod(QUIP_PATH, 0666);
if (listen(qpsock, SOMAXCONN) < 0) {
LOG(LOG_ERR, errno, "can't listen to %s", QUIP_PATH);
close(qpsock);
qpsock = -1;
}
}
if (daemonize) {
daemon(0, 0);
/* save pid to the pid file (/var/tmp/altqd.pid) */
#ifdef __FreeBSD__
{
FILE *fp;
if ((fp = fopen(ALTQD_PID_FILE, "w")) != NULL) {
fprintf(fp, "%d\n", getpid());
fclose(fp);
} else
LOG(LOG_WARNING, errno, "can't open pid file");
}
#else
pidfile(NULL);
#endif
} else {
/* interactive mode */
fp = stdin;
printf("\nEnter ? or command:\n");
printf("altqd %s> ", cur_ifname());
fflush(stdout);
}
/*
* go into the command mode.
*/
FD_ZERO(&fds);
maxfd = 0;
if (fp != NULL) {
fd = fileno(fp);
if (fd == -1)
LOG(LOG_ERR, 0, "bad file descriptor", QUIP_PATH);
} else
fd = -1;
if (fd != -1) {
FD_SET(fd, &fds);
maxfd = MAX(maxfd, fd + 1);
}
if (qpsock >= 0) {
FD_SET(qpsock, &fds);
maxfd = MAX(maxfd, qpsock + 1);
}
rval = 1;
while (rval) {
if (gotsig_hup) {
qcmd_destroyall();
gotsig_hup = 0;
LOG(LOG_INFO, 0, "reinitializing altqd...");
if (qcmd_init() != 0) {
LOG(LOG_INFO, 0, "reinitialization failed");
break;
}
}
if (gotsig_term || gotsig_int) {
LOG(LOG_INFO, 0, "Exiting on signal %d",
gotsig_term ? SIGTERM : SIGINT);
break;
}
FD_COPY(&fds, &rfds);
if (select(maxfd, &rfds, NULL, NULL, NULL) < 0) {
if (errno != EINTR)
err(1, "select");
continue;
}
/*
* if there is command input, read the input line,
* parse it, and execute.
*/
if (fp && FD_ISSET(fd, &rfds)) {
rval = do_command(fp);
if (rval == 0) {
/* quit command or eof on input */
LOG(LOG_INFO, 0, "Exiting.");
} else if (fp == stdin)
printf("altqd %s> ", cur_ifname());
fflush(stdout);
} else if (qpsock >= 0 && FD_ISSET(qpsock, &rfds)) {
/*
* quip connection request from client via unix
* domain socket; get a new socket for this
* connection and add it to the select list.
*/
int newsock = accept(qpsock, NULL, NULL);
if (newsock == -1) {
LOG(LOG_ERR, errno, "accept");
continue;
}
FD_SET(newsock, &fds);
for (i = 0; i < MAX_CLIENT; i++)
if (client[i] == NULL) {
client[i] = fdopen(newsock, "r+");
break;
}
maxfd = MAX(maxfd, newsock + 1);
} else {
/*
* check input from a client via unix domain socket
*/
for (i = 0; i < MAX_CLIENT; i++) {
int fd1;
if (client[i] == NULL)
continue;
fd1 = fileno(client[i]);
if (FD_ISSET(fd1, &rfds)) {
if (quip_input(client[i]) != 0 ||
fflush(client[i]) != 0) {
/* connection closed */
fclose(client[i]);
client[i] = NULL;
FD_CLR(fd1, &fds);
}
}
}
}
}
/* cleanup and exit */
qcmd_destroyall();
if (qpsock >= 0)
(void)close(qpsock);
unlink(QUIP_PATH);
for (i = 0; i < MAX_CLIENT; i++)
if (client[i] != NULL)
(void)fclose(client[i]);
if (daemonize) {
#ifdef __FreeBSD__
/* if we have a pid file, remove it */
unlink(ALTQD_PID_FILE);
#endif
closelog();
}
exit(0);
}
int
main(int argc, char **argv)
{
krb5_error_code ret;
krb5_context context;
void *kadm_handle;
kadm5_server_context *server_context;
kadm5_config_params conf;
krb5_socket_t signal_fd, listen_fd;
int log_fd;
slave *slaves = NULL;
uint32_t current_version = 0, old_version = 0;
krb5_keytab keytab;
char **files;
int aret;
(void) krb5_program_setup(&context, argc, argv, args, num_args, NULL);
if(help_flag)
krb5_std_usage(0, args, num_args);
if(version_flag) {
print_version(NULL);
exit(0);
}
setup_signal();
if (config_file == NULL) {
aret = asprintf(&config_file, "%s/kdc.conf", hdb_db_dir(context));
if (aret == -1 || config_file == NULL)
errx(1, "out of memory");
}
ret = krb5_prepend_config_files_default(config_file, &files);
if (ret)
krb5_err(context, 1, ret, "getting configuration files");
ret = krb5_set_config_files(context, files);
krb5_free_config_files(files);
if (ret)
krb5_err(context, 1, ret, "reading configuration files");
time_before_gone = parse_time (slave_time_gone, "s");
if (time_before_gone < 0)
krb5_errx (context, 1, "couldn't parse time: %s", slave_time_gone);
time_before_missing = parse_time (slave_time_missing, "s");
if (time_before_missing < 0)
krb5_errx (context, 1, "couldn't parse time: %s", slave_time_missing);
#ifdef SUPPORT_DETACH
if (detach_from_console) {
aret = daemon(0, 0);
if (aret == -1) {
/* not much to do if detaching fails... */
krb5_err(context, 1, aret, "failed to daemon(3)ise");
}
}
#endif
pidfile (NULL);
krb5_openlog (context, "ipropd-master", &log_facility);
krb5_set_warn_dest(context, log_facility);
ret = krb5_kt_register(context, &hdb_kt_ops);
if(ret)
krb5_err(context, 1, ret, "krb5_kt_register");
ret = krb5_kt_resolve(context, keytab_str, &keytab);
if(ret)
krb5_err(context, 1, ret, "krb5_kt_resolve: %s", keytab_str);
memset(&conf, 0, sizeof(conf));
if(realm) {
conf.mask |= KADM5_CONFIG_REALM;
conf.realm = realm;
}
ret = kadm5_init_with_skey_ctx (context,
KADM5_ADMIN_SERVICE,
NULL,
KADM5_ADMIN_SERVICE,
&conf, 0, 0,
&kadm_handle);
if (ret)
krb5_err (context, 1, ret, "kadm5_init_with_password_ctx");
server_context = (kadm5_server_context *)kadm_handle;
log_fd = open (server_context->log_context.log_file, O_RDONLY, 0);
if (log_fd < 0)
krb5_err (context, 1, errno, "open %s",
server_context->log_context.log_file);
signal_fd = make_signal_socket (context);
listen_fd = make_listen_socket (context, port_str);
kadm5_log_get_version_fd (log_fd, ¤t_version);
krb5_warnx(context, "ipropd-master started at version: %lu",
(unsigned long)current_version);
while(exit_flag == 0){
slave *p;
fd_set readset;
int max_fd = 0;
struct timeval to = {30, 0};
uint32_t vers;
#ifndef NO_LIMIT_FD_SETSIZE
if (signal_fd >= FD_SETSIZE || listen_fd >= FD_SETSIZE)
krb5_errx (context, 1, "fd too large");
#endif
FD_ZERO(&readset);
FD_SET(signal_fd, &readset);
max_fd = max(max_fd, signal_fd);
FD_SET(listen_fd, &readset);
max_fd = max(max_fd, listen_fd);
for (p = slaves; p != NULL; p = p->next) {
if (p->flags & SLAVE_F_DEAD)
continue;
FD_SET(p->fd, &readset);
max_fd = max(max_fd, p->fd);
}
ret = select (max_fd + 1,
&readset, NULL, NULL, &to);
if (ret < 0) {
if (errno == EINTR)
continue;
else
krb5_err (context, 1, errno, "select");
}
if (ret == 0) {
old_version = current_version;
kadm5_log_get_version_fd (log_fd, ¤t_version);
if (current_version > old_version) {
krb5_warnx(context,
"Missed a signal, updating slaves %lu to %lu",
(unsigned long)old_version,
(unsigned long)current_version);
for (p = slaves; p != NULL; p = p->next) {
if (p->flags & SLAVE_F_DEAD)
continue;
send_diffs (context, p, log_fd, database, current_version);
}
}
}
if (ret && FD_ISSET(signal_fd, &readset)) {
#ifndef NO_UNIX_SOCKETS
struct sockaddr_un peer_addr;
#else
struct sockaddr_storage peer_addr;
#endif
socklen_t peer_len = sizeof(peer_addr);
if(recvfrom(signal_fd, (void *)&vers, sizeof(vers), 0,
(struct sockaddr *)&peer_addr, &peer_len) < 0) {
krb5_warn (context, errno, "recvfrom");
continue;
}
--ret;
assert(ret >= 0);
old_version = current_version;
kadm5_log_get_version_fd (log_fd, ¤t_version);
if (current_version > old_version) {
krb5_warnx(context,
"Got a signal, updating slaves %lu to %lu",
(unsigned long)old_version,
(unsigned long)current_version);
for (p = slaves; p != NULL; p = p->next) {
if (p->flags & SLAVE_F_DEAD)
continue;
send_diffs (context, p, log_fd, database, current_version);
}
} else {
krb5_warnx(context,
"Got a signal, but no update in log version %lu",
(unsigned long)current_version);
}
}
for(p = slaves; p != NULL; p = p->next) {
if (p->flags & SLAVE_F_DEAD)
continue;
if (ret && FD_ISSET(p->fd, &readset)) {
--ret;
assert(ret >= 0);
if(process_msg (context, p, log_fd, database, current_version))
slave_dead(context, p);
} else if (slave_gone_p (p))
slave_dead(context, p);
else if (slave_missing_p (p))
send_are_you_there (context, p);
}
if (ret && FD_ISSET(listen_fd, &readset)) {
add_slave (context, keytab, &slaves, listen_fd);
--ret;
assert(ret >= 0);
}
write_stats(context, slaves, current_version);
}
if(exit_flag == SIGINT || exit_flag == SIGTERM)
krb5_warnx(context, "%s terminated", getprogname());
#ifdef SIGXCPU
else if(exit_flag == SIGXCPU)
krb5_warnx(context, "%s CPU time limit exceeded", getprogname());
#endif
else
krb5_warnx(context, "%s unexpected exit reason: %ld",
getprogname(), (long)exit_flag);
write_master_down(context);
return 0;
}
int
main(int argc, char **argv)
{
krb5_error_code ret;
char **files;
int optidx = 0;
int i;
krb5_log_facility *logfacility;
krb5_keytab keytab;
krb5_socket_t sfd = rk_INVALID_SOCKET;
setprogname(argv[0]);
ret = krb5_init_context(&context);
if (ret)
errx (1, "krb5_init_context failed: %d", ret);
if (getarg(args, num_args, argc, argv, &optidx)) {
warnx("error at argument `%s'", argv[optidx]);
usage(1);
}
if (help_flag)
usage (0);
if (version_flag) {
print_version(NULL);
exit(0);
}
argc -= optidx;
argv += optidx;
if (config_file == NULL) {
asprintf(&config_file, "%s/kdc.conf", hdb_db_dir(context));
if (config_file == NULL)
errx(1, "out of memory");
}
ret = krb5_prepend_config_files_default(config_file, &files);
if (ret)
krb5_err(context, 1, ret, "getting configuration files");
ret = krb5_set_config_files(context, files);
krb5_free_config_files(files);
if(ret)
krb5_err(context, 1, ret, "reading configuration files");
ret = krb5_openlog(context, "kadmind", &logfacility);
if (ret)
krb5_err(context, 1, ret, "krb5_openlog");
ret = krb5_set_warn_dest(context, logfacility);
if (ret)
krb5_err(context, 1, ret, "krb5_set_warn_dest");
ret = krb5_kt_register(context, &hdb_kt_ops);
if(ret)
krb5_err(context, 1, ret, "krb5_kt_register");
ret = krb5_kt_resolve(context, keytab_str, &keytab);
if(ret)
krb5_err(context, 1, ret, "krb5_kt_resolve");
kadm5_setup_passwd_quality_check (context, check_library, check_function);
for (i = 0; i < policy_libraries.num_strings; i++) {
ret = kadm5_add_passwd_quality_verifier(context,
policy_libraries.strings[i]);
if (ret)
krb5_err(context, 1, ret, "kadm5_add_passwd_quality_verifier");
}
ret = kadm5_add_passwd_quality_verifier(context, NULL);
if (ret)
krb5_err(context, 1, ret, "kadm5_add_passwd_quality_verifier");
if(debug_flag) {
int debug_port;
if(port_str == NULL)
debug_port = krb5_getportbyname (context, "kerberos-adm",
"tcp", 749);
else
debug_port = htons(atoi(port_str));
mini_inetd(debug_port, &sfd);
} else {
#ifdef _WIN32
pidfile(NULL);
start_server(context, port_str);
#else
struct sockaddr_storage __ss;
struct sockaddr *sa = (struct sockaddr *)&__ss;
socklen_t sa_size = sizeof(__ss);
/*
* Check if we are running inside inetd or not, if not, start
* our own server.
*/
if(roken_getsockname(STDIN_FILENO, sa, &sa_size) < 0 &&
rk_SOCK_ERRNO == ENOTSOCK) {
pidfile(NULL);
start_server(context, port_str);
}
#endif /* _WIN32 */
sfd = STDIN_FILENO;
}
if(realm)
krb5_set_default_realm(context, realm); /* XXX */
kadmind_loop(context, keytab, sfd);
return 0;
}
void DeviceSettings::slotApply()
{
bool succeed = true;
/* Manual Settings */
if ( manualButton->isChecked() ) {
// SET IP
int ret = set_iface( _dev.ascii(),
ipaddr->text().ascii(),
// we can ommit broadcast and netmask.
broadcast->text().length() ? broadcast->text().ascii() : 0,
netmask->text().length() ? netmask->text().ascii() : 0
);
if ( ret < 0 ) succeed = false;
// SET ROUTE
if ( !defaultgw->text().isEmpty() ) {
ret = set_default_route( defaultgw->text().ascii() );
if ( ret < 0 ) succeed = false;
}
ret = writeDnsList();
if ( ret < 0 ) succeed = false;
}
/* Automatic (DHCP) */
else if ( automaticButton->isChecked() ) {
// I don't like to invoke programs directly
// but we have no chance for now,
// this is clearly a bad hack :(.
QFile pidfile( "/var/run/dhcpcd-" + _dev + ".pid" );
if ( pidfile.exists() ) {
KProcess killdhcpcd;
killdhcpcd << "/sbin/dhcpcd" << "-k" << _dev;
killdhcpcd.start();
killdhcpcd.wait();
// how ugly... wait 2 seconds to dhcpcd to finish its work...
if ( killdhcpcd.normalExit() )
QTimer::singleShot( 2000, this, SLOT( startDhcpcd() ) );
else
printf( "failed (kill)\n" );
}
else
startDhcpcd();
}
writeSettings();
if ( succeed ) {
QString msg = i18n( "Successfully configured device: " ) + _dev;
KMessageBox::information( this, msg, i18n( "Done!" ) );
}
else {
QString msg = i18n( "Failed to configure device: " ) + _dev;
KMessageBox::error( this, msg, i18n( "Error!" ) );
}
done( 0 );
}