/*
* Clear traps on a fork.
*/
void
clear_traps(void)
{
char *volatile *tp;
for (tp = trap ; tp <= &trap[_NSIG - 1] ; tp++) {
if (*tp && **tp) { /* trap not NULL or SIG_IGN */
INTOFF;
ckfree(*tp);
*tp = NULL;
if (tp != &trap[0])
setsignal(tp - trap);
INTON;
}
}
}
void
clear_traps(void)
{
char **tp;
INTOFF;
for (tp = trap ; tp < &trap[NSIG] ; tp++) {
if (*tp && **tp) { /* trap not NULL or SIG_IGN */
ckfree(*tp);
*tp = NULL;
if (tp != &trap[0])
setsignal(tp - trap);
}
}
trapcnt = 0;
INTON;
}
void
setjobctl(int on)
{
int fd;
int pgrp;
if (on == jobctl || rootshell == 0)
return;
if (on) {
int ofd;
ofd = fd = open(_PATH_TTY, O_RDWR);
if (fd < 0) {
fd += 3;
while (!isatty(fd))
if (--fd < 0)
goto out;
}
fd = savefd(fd, ofd);
do { /* while we are in the background */
if ((pgrp = tcgetpgrp(fd)) < 0) {
out:
sh_warnx("can't access tty; job control turned off");
mflag = on = 0;
goto close;
}
if (pgrp == getpgrp())
break;
killpg(0, SIGTTIN);
} while (1);
initialpgrp = pgrp;
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
pgrp = rootpid;
setpgid(0, pgrp);
xtcsetpgrp(fd, pgrp);
} else {
/* turning job control off */
fd = ttyfd;
pgrp = initialpgrp;
xtcsetpgrp(fd, pgrp);
setpgid(0, pgrp);
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
close:
close(fd);
fd = -1;
}
ttyfd = fd;
jobctl = on;
}
void
clear_traps(int vforked)
{
char **tp;
for (tp = trap ; tp <= &trap[NSIG] ; tp++) {
if (*tp && **tp) { /* trap not NULL or SIG_IGN */
INTOFF;
if (!vforked) {
ckfree(*tp);
*tp = NULL;
}
if (tp != &trap[0])
setsignal(tp - trap, vforked);
INTON;
}
}
}
void
clear_traps(shinstance *psh, int vforked)
{
char **tp;
for (tp = psh->trap ; tp <= &psh->trap[NSIG] ; tp++) {
if (*tp && **tp) { /* trap not NULL or SIG_IGN */
INTOFF;
if (!vforked) {
ckfree(psh, *tp);
*tp = NULL;
}
if (tp != &psh->trap[0])
setsignal(psh, (int)(tp - psh->trap), vforked);
INTON;
}
}
}
/*
* Clear traps on a fork or vfork.
* Takes one arg vfork, to tell it to not be destructive of
* the parents variables.
*/
void
clear_traps(int vforked)
{
char * volatile *tp;
VTRACE(DBG_TRAP, ("clear_traps(%d)\n", vforked));
if (!vforked)
traps_invalid = 1;
for (tp = &trap[1] ; tp < &trap[NSIG] ; tp++) {
if (*tp && **tp) { /* trap not NULL or SIG_IGN */
INTOFF;
setsignal(tp - trap, vforked == 1);
INTON;
}
}
if (vforked == 2)
free_traps();
}
static void shell(ssh_session_t *session)
{
ssh_channel_t *channel;
struct termios terminal_local;
int interactive=isatty(0);
channel = ssh_channel_new(session);
if(interactive)
{
tcgetattr(0,&terminal_local);
memcpy(&terminal,&terminal_local,sizeof(struct termios));
}
if(ssh_channel_open_session(channel))
{
printf("error opening channel : %s\n",ssh_get_error(session));
return;
}
chan = channel;
if(interactive)
{
ssh_channel_request_pty(channel);
sizechanged();
}
if(ssh_channel_request_shell(channel))
{
printf("Requesting shell : %s\n", ssh_get_error(session));
return;
}
if(interactive)
{
cfmakeraw(&terminal_local);
tcsetattr(0,TCSANOW,&terminal_local);
setsignal();
}
signal(SIGTERM,do_cleanup);
select_loop(session,channel);
if(interactive) {
do_cleanup(0);
}
}
void
setjobctl(on) {
#ifdef OLD_TTY_DRIVER
int ldisc;
#endif
if (on == jobctl || rootshell == 0)
return;
if (on) {
do { /* while we are in the background */
if (ioctl(2, TIOCGPGRP, (char *)&initialpgrp) < 0) {
out2str("sh: can't access tty; job control turned off\n");
mflag = 0;
return;
}
if (initialpgrp == -1)
initialpgrp = getpgrp(0);
else if (initialpgrp != getpgrp(0)) {
killpg(initialpgrp, SIGTTIN);
continue;
}
} while (0);
#ifdef OLD_TTY_DRIVER
if (ioctl(2, TIOCGETD, (char *)&ldisc) < 0 || ldisc != NTTYDISC) {
out2str("sh: need new tty driver to run job control; job control turned off\n");
mflag = 0;
return;
}
#endif
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
setpgrp(0, rootpid);
ioctl(2, TIOCSPGRP, (char *)&rootpid);
} else { /* turning job control off */
setpgrp(0, initialpgrp);
ioctl(2, TIOCSPGRP, (char *)&initialpgrp);
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
}
jobctl = on;
}
void
forkchild(struct job *jp, union node *n, int mode, int vforked)
{
int wasroot;
int pgrp;
const char *devnull = _PATH_DEVNULL;
const char *nullerr = "Can't open %s";
wasroot = rootshell;
TRACE(("Child shell %d\n", getpid()));
if (!vforked)
rootshell = 0;
closescript(vforked);
clear_traps(vforked);
#if JOBS
if (!vforked)
jobctl = 0; /* do job control only in root shell */
if (wasroot && mode != FORK_NOJOB && mflag) {
if (jp == NULL || jp->nprocs == 0)
pgrp = getpid();
else
pgrp = jp->ps[0].pid;
/* This can fail because we are doing it in the parent also */
(void)setpgid(0, pgrp);
if (mode == FORK_FG) {
if (tcsetpgrp(ttyfd, pgrp) == -1)
error("Cannot set tty process group (%s) at %d",
strerror(errno), __LINE__);
}
setsignal(SIGTSTP, vforked);
setsignal(SIGTTOU, vforked);
} else if (mode == FORK_BG) {
ignoresig(SIGINT, vforked);
ignoresig(SIGQUIT, vforked);
if ((jp == NULL || jp->nprocs == 0) &&
! fd0_redirected_p ()) {
close(0);
if (open(devnull, O_RDONLY) != 0)
error(nullerr, devnull);
}
}
#else
if (mode == FORK_BG) {
ignoresig(SIGINT, vforked);
ignoresig(SIGQUIT, vforked);
if ((jp == NULL || jp->nprocs == 0) &&
! fd0_redirected_p ()) {
close(0);
if (open(devnull, O_RDONLY) != 0)
error(nullerr, devnull);
}
}
#endif
if (wasroot && iflag) {
setsignal(SIGINT, vforked);
setsignal(SIGQUIT, vforked);
setsignal(SIGTERM, vforked);
}
if (!vforked)
jobs_invalid = 1;
}
void
setjobctl(int on)
{
#ifdef OLD_TTY_DRIVER
int ldisc;
#endif
if (on == jobctl || rootshell == 0)
return;
if (on) {
#if defined(FIOCLEX) || defined(FD_CLOEXEC)
int err;
int i;
if (ttyfd != -1)
close(ttyfd);
if ((ttyfd = open("/dev/tty", O_RDWR)) == -1) {
for (i = 0; i < 3; i++) {
if (isatty(i) && (ttyfd = dup(i)) != -1)
break;
}
if (i == 3)
goto out;
}
/* Move to a high fd */
for (i = 10; i > 2; i--) {
if ((err = fcntl(ttyfd, F_DUPFD, (1 << i) - 1)) != -1)
break;
}
if (err != -1) {
close(ttyfd);
ttyfd = err;
}
#ifdef FIOCLEX
err = ioctl(ttyfd, FIOCLEX, 0);
#elif FD_CLOEXEC
err = fcntl(ttyfd, F_SETFD,
fcntl(ttyfd, F_GETFD, 0) | FD_CLOEXEC);
#endif
if (err == -1) {
close(ttyfd);
ttyfd = -1;
goto out;
}
#else
out2str("sh: Need FIOCLEX or FD_CLOEXEC to support job control");
goto out;
#endif
do { /* while we are in the background */
if ((initialpgrp = tcgetpgrp(ttyfd)) < 0) {
out:
out2str("sh: can't access tty; job control turned off\n");
mflag = 0;
return;
}
if (initialpgrp == -1)
initialpgrp = getpgrp();
else if (initialpgrp != getpgrp()) {
killpg(0, SIGTTIN);
continue;
}
} while (0);
#ifdef OLD_TTY_DRIVER
if (ioctl(ttyfd, TIOCGETD, (char *)&ldisc) < 0
|| ldisc != NTTYDISC) {
out2str("sh: need new tty driver to run job control; job control turned off\n");
mflag = 0;
return;
}
#endif
setsignal(SIGTSTP, 0);
setsignal(SIGTTOU, 0);
setsignal(SIGTTIN, 0);
if (getpgrp() != rootpid && setpgid(0, rootpid) == -1)
error("Cannot set process group (%s) at %d",
strerror(errno), __LINE__);
if (tcsetpgrp(ttyfd, rootpid) == -1)
error("Cannot set tty process group (%s) at %d",
strerror(errno), __LINE__);
} else { /* turning job control off */
if (getpgrp() != initialpgrp && setpgid(0, initialpgrp) == -1)
error("Cannot set process group (%s) at %d",
strerror(errno), __LINE__);
if (tcsetpgrp(ttyfd, initialpgrp) == -1)
error("Cannot set tty process group (%s) at %d",
strerror(errno), __LINE__);
close(ttyfd);
ttyfd = -1;
setsignal(SIGTSTP, 0);
setsignal(SIGTTOU, 0);
setsignal(SIGTTIN, 0);
}
jobctl = on;
}
int serv_loop()
{
int cs, ss = 0;
struct sockaddr_storage cl;
fd_set readable;
int i, n, len;
char cl_addr[NI_MAXHOST];
char cl_name[NI_MAXHOST];
int error;
pid_t pid;
#ifdef USE_THREAD
if (threading) {
blocksignal(SIGHUP);
blocksignal(SIGINT);
blocksignal(SIGUSR1);
}
#endif
for (;;) {
readable = allsock;
MUTEX_LOCK(mutex_select);
n = select(maxsock+1, &readable, 0, 0, 0);
if (n <= 0) {
if (n < 0 && errno != EINTR) {
msg_out(warn, "select: %m");
}
MUTEX_UNLOCK(mutex_select);
continue;
}
#ifdef USE_THREAD
if ( ! threading ) {
#endif
/* handle any queued signal flags */
if (FD_ISSET(sig_queue[0], &readable)) {
if (ioctl(sig_queue[0], FIONREAD, &i) != 0) {
msg_out(crit, "ioctl: %m");
exit(-1);
}
while (--i >= 0) {
char c;
if (read(sig_queue[0], &c, 1) != 1) {
msg_out(crit, "read: %m");
exit(-1);
}
switch(c) {
case 'H': /* sighup */
reload();
break;
case 'C': /* sigchld */
reapchild();
break;
case 'T': /* sigterm */
cleanup();
break;
default:
break;
}
}
}
#ifdef USE_THREAD
}
#endif
for ( i = 0; i < serv_sock_ind; i++ ) {
if (FD_ISSET(serv_sock[i], &readable)) {
n--;
break;
}
}
if ( n < 0 || i >= serv_sock_ind ) {
MUTEX_UNLOCK(mutex_select);
continue;
}
len = sizeof(struct sockaddr_storage);
cs = accept(serv_sock[i], (struct sockaddr *)&cl, (socklen_t *)&len);
if (cs < 0) {
if (errno == EINTR
#ifdef SOLARIS
|| errno == EPROTO
#endif
|| errno == EWOULDBLOCK
|| errno == ECONNABORTED) {
; /* ignore */
} else {
/* real accept error */
msg_out(warn, "accept: %m");
}
MUTEX_UNLOCK(mutex_select);
continue;
}
MUTEX_UNLOCK(mutex_select);
#ifdef USE_THREAD
if ( !threading ) {
#endif
if (max_child > 0 && cur_child >= max_child) {
msg_out(warn, "child: cur %d; exeedeing max(%d)",
cur_child, max_child);
close(cs);
continue;
}
#ifdef USE_THREAD
}
#endif
error = getnameinfo((struct sockaddr *)&cl, len,
cl_addr, sizeof(cl_addr),
NULL, 0,
NI_NUMERICHOST);
if (resolv_client) {
error = getnameinfo((struct sockaddr *)&cl, len,
cl_name, sizeof(cl_name),
NULL, 0, 0);
msg_out(norm, "%s[%s] connected", cl_name, cl_addr);
} else {
msg_out(norm, "%s connected", cl_addr);
strncpy(cl_name, cl_addr, sizeof(cl_name));
}
i = validate_access(cl_addr, cl_name);
if (i < 1) {
/* access denied */
close(cs);
continue;
}
set_blocking(cs);
#ifdef USE_THREAD
if (!threading ) {
#endif
blocksignal(SIGHUP);
blocksignal(SIGCHLD);
pid = fork();
switch (pid) {
case -1: /* fork child failed */
printf("\nfork failed\n");
break;
case 0: /* i am child */
for ( i = 0; i < serv_sock_ind; i++ ) {
close(serv_sock[i]);
}
setsignal(SIGCHLD, SIG_DFL);
setsignal(SIGHUP, SIG_DFL);
releasesignal(SIGCHLD);
releasesignal(SIGHUP);
ss = proto_socks(cs);
if ( ss == -1 ) {
close(cs); /* may already be closed */
exit(1);
}
printf("\nrelaying\n");
relay(cs, ss);
exit(0);
default: /* may be parent */
printf("\nadding proc\n");
proclist_add(pid);
break;
}
close(cs);
releasesignal(SIGHUP);
releasesignal(SIGCHLD);
#ifdef USE_THREAD
} else {
ss = proto_socks(cs);
if ( ss == -1 ) {
close(cs); /* may already be closed */
continue;
}
relay(cs, ss);
}
#endif
}
}
int
main(int argc, char **argv)
{
register char *cp;
register int op, pid, snaplen, timeout, linktype, status;
#ifdef TIOCNOTTY
register int fd;
#endif
register pcap_t *pd;
register char *interface, *rfilename;
struct bpf_program code;
char errbuf[PCAP_ERRBUF_SIZE];
if (argv[0] == NULL)
prog = "arpwatch";
else if ((cp = strrchr(argv[0], '/')) != NULL)
prog = cp + 1;
else
prog = argv[0];
if (abort_on_misalignment(errbuf) < 0) {
(void)fprintf(stderr, "%s: %s\n", prog, errbuf);
exit(1);
}
opterr = 0;
interface = NULL;
rfilename = NULL;
pd = NULL;
while ((op = getopt(argc, argv, "df:i:n:Nr:")) != EOF)
switch (op) {
case 'd':
++debug;
#ifndef DEBUG
(void)fprintf(stderr,
"%s: Warning: Not compiled with -DDEBUG\n", prog);
#endif
break;
case 'f':
arpfile = optarg;
break;
case 'i':
interface = optarg;
break;
case 'n':
if (!addnet(optarg))
usage();
break;
case 'N':
++nobogons;
break;
case 'r':
rfilename = optarg;
break;
default:
usage();
}
if (optind != argc)
usage();
if (rfilename != NULL) {
net = 0;
netmask = 0;
} else {
/* Determine interface if not specified */
if (interface == NULL &&
(interface = pcap_lookupdev(errbuf)) == NULL) {
(void)fprintf(stderr, "%s: lookup_device: %s\n",
prog, errbuf);
exit(1);
}
/* Determine network and netmask */
if (pcap_lookupnet(interface, &net, &netmask, errbuf) < 0) {
(void)fprintf(stderr, "%s: bad interface %s: %s\n",
prog, interface, errbuf);
exit(1);
}
/* Drop into the background if not debugging */
if (!debug) {
pid = fork();
if (pid < 0) {
syslog(LOG_ERR, "main fork(): %m");
exit(1);
} else if (pid != 0)
exit(0);
(void)close(fileno(stdin));
(void)close(fileno(stdout));
(void)close(fileno(stderr));
#ifdef TIOCNOTTY
fd = open("/dev/tty", O_RDWR);
if (fd >= 0) {
(void)ioctl(fd, TIOCNOTTY, 0);
(void)close(fd);
}
#else
(void) setsid();
#endif
}
}
openlog(prog, 0, LOG_DAEMON);
if (chdir(arpdir) < 0) {
syslog(LOG_ERR, "chdir(%s): %m", arpdir);
syslog(LOG_ERR, "(using current working directory)");
}
if (rfilename != NULL) {
pd = pcap_open_offline(rfilename, errbuf);
if (pd == NULL) {
syslog(LOG_ERR, "pcap open %s: %s", rfilename, errbuf);
exit(1);
}
swapped = pcap_is_swapped(pd);
} else {
snaplen = max(sizeof(struct ether_header),
sizeof(struct fddi_header)) + sizeof(struct ether_arp);
timeout = 1000;
pd = pcap_open_live(interface, snaplen, 1, timeout, errbuf);
if (pd == NULL) {
syslog(LOG_ERR, "pcap open %s: %s", interface, errbuf);
exit(1);
}
#ifdef WORDS_BIGENDIAN
swapped = 1;
#endif
}
/*
* Revert to non-privileged user after opening sockets
* (not needed on most systems).
*/
setgid(getgid());
setuid(getuid());
/* Must be ethernet or fddi */
linktype = pcap_datalink(pd);
if (linktype != DLT_EN10MB && linktype != DLT_FDDI) {
syslog(LOG_ERR, "Link layer type %d not ethernet or fddi",
linktype);
exit(1);
}
/* Compile and install filter */
if (pcap_compile(pd, &code, "arp or rarp", 1, netmask) < 0) {
syslog(LOG_ERR, "pcap_compile: %s", pcap_geterr(pd));
exit(1);
}
if (pcap_setfilter(pd, &code) < 0) {
syslog(LOG_ERR, "pcap_setfilter: %s", pcap_geterr(pd));
exit(1);
}
if (rfilename == NULL)
syslog(LOG_INFO, "listening on %s", interface);
/* Read in database */
initializing = 1;
if (!readdata())
exit(1);
sorteinfo();
#ifdef DEBUG
if (debug > 2) {
debugdump();
exit(0);
}
#endif
initializing = 0;
(void)setsignal(SIGINT, die);
(void)setsignal(SIGTERM, die);
(void)setsignal(SIGHUP, die);
if (rfilename == NULL) {
(void)setsignal(SIGQUIT, checkpoint);
(void)setsignal(SIGALRM, checkpoint);
(void)alarm(CHECKPOINT);
}
switch (linktype) {
case DLT_EN10MB:
status = pcap_loop(pd, 0, process_ether, NULL);
break;
case DLT_FDDI:
status = pcap_loop(pd, 0, process_fddi, NULL);
break;
default:
syslog(LOG_ERR, "bad linktype %d (can't happen)", linktype);
exit(1);
}
if (status < 0) {
syslog(LOG_ERR, "pcap_loop: %s", pcap_geterr(pd));
exit(1);
}
pcap_close(pd);
if (!dump())
exit(1);
exit(0);
}
int main(int argc, char **argv)
{
memset(&global_info, 0, sizeof(global_info_t));
char *url = http_url;
global_info.round = 1;
int opt;
while ((opt = getopt(argc, argv, "w:t:r:hs")) != -1) {
switch (opt) {
case 'w':
global_info.work_num = atoi(optarg);
break;
case 't':
global_info.thread_num = atoi(optarg);
break;
case 'r':
global_info.round = atoi(optarg);
break;
case 's':
url = https_url;
break;
case 'h':
default:
show_help();
return EXIT_SUCCESS;
}
}
if (global_info.work_num == 0 || global_info.thread_num == 0) {
show_help();
return EXIT_FAILURE;
}
setsignal(SIGINT, _sig_int);
setsignal(SIGTERM, _sig_int);
printf("get work num: %u, thread num: %u\n", global_info.work_num, global_info.thread_num);
thread_info_t *thread_list = calloc(global_info.thread_num, sizeof(thread_info_t));
if (thread_list == NULL) {
printf("alloc threads error\n");
return EXIT_FAILURE;
}
global_info.work_list = calloc(global_info.work_num, sizeof(work_info_t *));
if (global_info.work_list == NULL) {
printf("alloc work_list error\n");
return EXIT_FAILURE;
}
int idx = 0;
for (idx = 0; idx < global_info.work_num; ++idx) {
global_info.work_list[idx] = calloc(1, sizeof(work_info_t));
if (global_info.work_list[idx] == NULL) {
printf("alloc work_list %u error\n", idx);
return EXIT_FAILURE;
}
global_info.work_list[idx]->url = url;
global_info.work_list[idx]->idx = idx;
}
/* Must initialize libcurl before any threads are started */
curl_global_init(CURL_GLOBAL_ALL);
init_locks();
TS_INIT();
mutexlock_init(global_info.rmtx);
mutexlock_init(global_info.wmtx);
TS_DECLARE(perf);
for (idx = 0; idx < global_info.thread_num; ++idx) {
thread_list[idx].global_info = &global_info;
thread_list[idx].curl = curl_easy_init();
thread_list[idx].multi_handle = curl_multi_init();
if (thread_list[idx].curl == NULL || thread_list[idx].multi_handle == NULL) {
printf("error when curl init\n");
return EXIT_FAILURE;
}
//curl_easy_setopt(thread_list[idx].curl, CURLOPT_FORBID_REUSE, 1L);
curl_easy_setopt(thread_list[idx].curl, CURLOPT_NOSIGNAL, 1L);
if (url == https_url) {
curl_easy_setopt(thread_list[idx].curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(thread_list[idx].curl, CURLOPT_SSL_VERIFYHOST, 0L);
}
thread_list[idx].idx = idx;
set_share_handle(thread_list[idx].curl);
}
int error;
TS_BEGIN(perf);
for (idx = 0; idx < global_info.thread_num; ++idx) {
error = pthread_create(&(thread_list[idx].tid),
NULL, /* default attributes please */
pull_one_url,
(void *) & (thread_list[idx]));
if (0 != error) {
fprintf(stderr, "Couldn't run thread number %d, errno %d\n", idx, error);
return EXIT_FAILURE;
}
}
/* now wait for all threads to terminate */
for (idx = 0; idx < global_info.thread_num; idx++) {
error = pthread_join(thread_list[idx].tid, NULL);
//printf("[%u:%lu]Thread %d terminated\n", idx, time(NULL), idx);
}
TS_END(perf);
for (idx = 0; idx < global_info.thread_num; idx++) {
curl_easy_cleanup(thread_list[idx].curl);
curl_multi_cleanup(thread_list[idx].multi_handle);
}
free(thread_list);
unsigned long total_length = 0;
for (idx = 0; idx < global_info.work_num; idx++) {
if (global_info.work_list[idx]) {
if (global_info.work_list[idx]->status == STAT_DONE) {
total_length += global_info.work_list[idx]->data_len;
}
free(global_info.work_list[idx]);
}
}
free(global_info.work_list);
printf("RATE: worknum:%u total_length:%lu total_ms_diff:%lu, %.1fK\n",
global_info.work_num, total_length, TS_MSDIFF(perf), (double)(total_length) / (double)(TS_MSDIFF(perf)));
kill_locks();
curl_global_cleanup();
return EXIT_SUCCESS;
}
void* ThreadFunction2(void* port)
{
int secondcounter = 0;
int outtransition = 0;
int state = (int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetPointImpl@7c26a0ba (initial: true) (point: [POINT_19, POINT_20, POINT_23, POINT_24], direction: BRANCH)"));
if (DEBUGCONTROLLER) printf("Thread 'org.eclipse.internal.xpand2.type.XpandIterator@432dbb4b' started.\n");
while(1) {
if (DEBUGCONTROLLER) printf("Entering state %d.\n",state);
//escape if railway system is down
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
//all states
if (state == -1) {}
else if (state == ((int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@73b61aea (initial: false) (track: [IC_JCT_0, IC_LN_0, IC_LN_1, IC_LN_2, IC_LN_3, IC_LN_4, IC_LN_5, IC_ST_0, IC_ST_2, IC_ST_4], speed: 100, direction: FWD)")))) {
P(2); // GET THE GLOBALLOCK
if (DEBUGCONTROLLER) printf("State %d (de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@73b61aea (initial: false) (track: [IC_JCT_0, IC_LN_0, IC_LN_1, IC_LN_2, IC_LN_3, IC_LN_4, IC_LN_5, IC_ST_0, IC_ST_2, IC_ST_4], speed: 100, direction: FWD)) entered.\n",(int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@73b61aea (initial: false) (track: [IC_JCT_0, IC_LN_0, IC_LN_1, IC_LN_2, IC_LN_3, IC_LN_4, IC_LN_5, IC_ST_0, IC_ST_2, IC_ST_4], speed: 100, direction: FWD)")));
//state1 entry code (SET SPEED)
settrack(railway, IC_JCT_0, FWD, 100);
setsignal(railway, IC_JCT_0, FIRST, OFF);
setsignal(railway, IC_JCT_0, SECOND, GREEN);
settrack(railway, IC_LN_0, FWD, 100);
setsignal(railway, IC_LN_0, FIRST, OFF);
setsignal(railway, IC_LN_0, SECOND, GREEN);
settrack(railway, IC_LN_1, FWD, 100);
setsignal(railway, IC_LN_1, FIRST, OFF);
setsignal(railway, IC_LN_1, SECOND, GREEN);
settrack(railway, IC_LN_2, FWD, 100);
setsignal(railway, IC_LN_2, FIRST, OFF);
setsignal(railway, IC_LN_2, SECOND, GREEN);
settrack(railway, IC_LN_3, FWD, 100);
setsignal(railway, IC_LN_3, FIRST, OFF);
setsignal(railway, IC_LN_3, SECOND, GREEN);
settrack(railway, IC_LN_4, FWD, 100);
setsignal(railway, IC_LN_4, FIRST, OFF);
setsignal(railway, IC_LN_4, SECOND, GREEN);
settrack(railway, IC_LN_5, FWD, 100);
setsignal(railway, IC_LN_5, FIRST, OFF);
setsignal(railway, IC_LN_5, SECOND, GREEN);
settrack(railway, IC_ST_0, FWD, 100);
setsignal(railway, IC_ST_0, FIRST, OFF);
setsignal(railway, IC_ST_0, SECOND, GREEN);
settrack(railway, IC_ST_2, FWD, 100);
setsignal(railway, IC_ST_2, FIRST, OFF);
setsignal(railway, IC_ST_2, SECOND, GREEN);
settrack(railway, IC_ST_4, FWD, 100);
setsignal(railway, IC_ST_4, FIRST, OFF);
setsignal(railway, IC_ST_4, SECOND, GREEN);
V(2); // RELEASE THE GLOBALLOCK
//state1 transitions code
secondcounter = 0;
while(1) {
P(2); // GET THE GLOBALLOCK
outtransition = 0;
if ((DEBUGCONTROLLER)&&(!(secondcounter%10))) printf("Transition wait (%d seconds).\n",secondcounter/10);
outtransition = 1;
//test for contact-events
if ((getcontact_sync(railway,IC_ST_2,FIRST,1) != 0)) {
V(2); // RELEASE THE GLOBALLOCK
if (DEBUGCONTROLLER) printf("Event-Transition taken.\n");
state = HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@2af590c6 (initial: false) (track: [IC_ST_0, IC_ST_2], speed: 30, direction: FWD)");
break;
}
V(2); // RELEASE THE GLOBALLOCK
//escape if railway system is down
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
//escape if not outtransitions
if (!outtransition) {
if (DEBUGCONTROLLER) printf("Final state - terminating thread.\n");
//set localTERMINATED := 1 (so that we not wait on this thread in any next macro-tick any more)
localTERMINATED2 = 1;
return (void *)1;
}//end if
secondcounter++;
usleep(100000); // sleep for 100ms
//set localLOCK := 1 and wait for its reset
localLOCK2 = 1;
while (localLOCK2 == 1){
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
usleep(5000); // sleep for 5ms
//if (DEBUGCONTROLLER) printf("Thread 2 waiting for next tick.\n");
}//end while
}//end while
}//end if
else if (state == ((int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetPointImpl@7c26a0ba (initial: true) (point: [POINT_19, POINT_20, POINT_23, POINT_24], direction: BRANCH)")))) {
P(2); // GET THE GLOBALLOCK
if (DEBUGCONTROLLER) printf("State %d (de.cau.cs.kieler.simplerailctrl.impl.SetPointImpl@7c26a0ba (initial: true) (point: [POINT_19, POINT_20, POINT_23, POINT_24], direction: BRANCH)) entered.\n",(int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetPointImpl@7c26a0ba (initial: true) (point: [POINT_19, POINT_20, POINT_23, POINT_24], direction: BRANCH)")));
//state2 enty code (SET POINT)
setpoint(railway, POINT_19, BRANCH);
setpoint(railway, POINT_20, BRANCH);
setpoint(railway, POINT_23, BRANCH);
setpoint(railway, POINT_24, BRANCH);
V(2); // RELEASE THE GLOBALLOCK
//state2 transitions code
secondcounter = 0;
while(1) {
P(2); // GET THE GLOBALLOCK
outtransition = 0;
if ((DEBUGCONTROLLER)&&(!(secondcounter%10))) printf("Transition wait (%d seconds).\n",secondcounter/10);
outtransition = 1;
//test for wait-events
if (secondcounter/10 >= 5) {
V(2); // RELEASE THE GLOBALLOCK
if (DEBUGCONTROLLER) printf("Wait-Transition taken.\n");
state = HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@73b61aea (initial: false) (track: [IC_JCT_0, IC_LN_0, IC_LN_1, IC_LN_2, IC_LN_3, IC_LN_4, IC_LN_5, IC_ST_0, IC_ST_2, IC_ST_4], speed: 100, direction: FWD)");
break;
}
V(2); // RELEASE THE GLOBALLOCK
//escape if railway system is down
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
//escape if not outtransitions
if (!outtransition) {
if (DEBUGCONTROLLER) printf("Final state - terminating thread.\n");
//set localTERMINATED := 1 (so that we not wait on this thread in any next macro-tick any more)
localTERMINATED2 = 1;
return (void *)1;
}//end if
secondcounter++;
usleep(100000); // sleep for 100ms
//set localLOCK := 1 and wait for its reset
localLOCK2 = 1;
while (localLOCK2 == 1){
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
usleep(5000); // sleep for 5ms
//if (DEBUGCONTROLLER) printf("Thread 2 waiting for next tick.\n");
}//end while
}//end while
}//end if
else if (state == ((int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@2af590c6 (initial: false) (track: [IC_ST_0, IC_ST_2], speed: 30, direction: FWD)")))) {
P(2); // GET THE GLOBALLOCK
if (DEBUGCONTROLLER) printf("State %d (de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@2af590c6 (initial: false) (track: [IC_ST_0, IC_ST_2], speed: 30, direction: FWD)) entered.\n",(int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@2af590c6 (initial: false) (track: [IC_ST_0, IC_ST_2], speed: 30, direction: FWD)")));
//state3 entry code (SET SPEED)
settrack(railway, IC_ST_0, FWD, 30);
setsignal(railway, IC_ST_0, FIRST, OFF);
setsignal(railway, IC_ST_0, SECOND, YELLOW);
settrack(railway, IC_ST_2, FWD, 30);
setsignal(railway, IC_ST_2, FIRST, OFF);
setsignal(railway, IC_ST_2, SECOND, YELLOW);
V(2); // RELEASE THE GLOBALLOCK
//state3 transitions code
secondcounter = 0;
while(1) {
P(2); // GET THE GLOBALLOCK
outtransition = 0;
if ((DEBUGCONTROLLER)&&(!(secondcounter%10))) printf("Transition wait (%d seconds).\n",secondcounter/10);
outtransition = 1;
//test for contact-events
if ((getcontact_sync(railway,IC_ST_2,SECOND,1) != 0)) {
V(2); // RELEASE THE GLOBALLOCK
if (DEBUGCONTROLLER) printf("Event-Transition taken.\n");
state = HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@5ff3cd32 (initial: false) (track: [IC_ST_2], speed: 0, direction: FWD)");
break;
}
V(2); // RELEASE THE GLOBALLOCK
//escape if railway system is down
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
//escape if not outtransitions
if (!outtransition) {
if (DEBUGCONTROLLER) printf("Final state - terminating thread.\n");
//set localTERMINATED := 1 (so that we not wait on this thread in any next macro-tick any more)
localTERMINATED2 = 1;
return (void *)1;
}//end if
secondcounter++;
usleep(100000); // sleep for 100ms
//set localLOCK := 1 and wait for its reset
localLOCK2 = 1;
while (localLOCK2 == 1){
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
usleep(5000); // sleep for 5ms
//if (DEBUGCONTROLLER) printf("Thread 2 waiting for next tick.\n");
}//end while
}//end while
}//end if
else if (state == ((int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@5ff3cd32 (initial: false) (track: [IC_ST_2], speed: 0, direction: FWD)")))) {
P(2); // GET THE GLOBALLOCK
if (DEBUGCONTROLLER) printf("State %d (de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@5ff3cd32 (initial: false) (track: [IC_ST_2], speed: 0, direction: FWD)) entered.\n",(int)(HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@5ff3cd32 (initial: false) (track: [IC_ST_2], speed: 0, direction: FWD)")));
//state4 entry code (SET SPEED)
settrack(railway, IC_ST_2, FWD, 0);
setsignal(railway, IC_ST_2, FIRST, OFF);
setsignal(railway, IC_ST_2, SECOND, RED);
V(2); // RELEASE THE GLOBALLOCK
//state4 transitions code
secondcounter = 0;
while(1) {
P(2); // GET THE GLOBALLOCK
outtransition = 0;
if ((DEBUGCONTROLLER)&&(!(secondcounter%10))) printf("Transition wait (%d seconds).\n",secondcounter/10);
outtransition = 1;
//test for wait-events
if (secondcounter/10 >= 10) {
V(2); // RELEASE THE GLOBALLOCK
if (DEBUGCONTROLLER) printf("Wait-Transition taken.\n");
state = HASH("de.cau.cs.kieler.simplerailctrl.impl.SetSpeedImpl@73b61aea (initial: false) (track: [IC_JCT_0, IC_LN_0, IC_LN_1, IC_LN_2, IC_LN_3, IC_LN_4, IC_LN_5, IC_ST_0, IC_ST_2, IC_ST_4], speed: 100, direction: FWD)");
break;
}
V(2); // RELEASE THE GLOBALLOCK
//escape if railway system is down
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
//escape if not outtransitions
if (!outtransition) {
if (DEBUGCONTROLLER) printf("Final state - terminating thread.\n");
//set localTERMINATED := 1 (so that we not wait on this thread in any next macro-tick any more)
localTERMINATED2 = 1;
return (void *)1;
}//end if
secondcounter++;
usleep(100000); // sleep for 100ms
//set localLOCK := 1 and wait for its reset
localLOCK2 = 1;
while (localLOCK2 == 1){
if (!railway_alive(railway)) {
if (DEBUGCONTROLLER) printf("Railway system down - terminating thread.\n");
exit(EXIT_FAILURE);
}//end if
usleep(5000); // sleep for 5ms
//if (DEBUGCONTROLLER) printf("Thread 2 waiting for next tick.\n");
}//end while
}//end while
}//end if
}//end while
}
/* this is code I used to see if I was getting signaled at one point, and it might be useful*/
int GettingSignaled(void)
{
char localhost[256];
struct hostent *hep = NULL;
int i=0;
/* see if we're getting signaled, damnit!*/
setsignal(SIGINT, handler);
/*setsignal(SIGKILL, handler);*/
/*setsignal(SIGSTOP, handler);*/
setsignal(SIGTERM, handler);
setsignal(SIGABRT, handler);
#ifndef WIN32
setsignal(SIGCHLD, handler);
setsignal(SIGHUP, SIG_IGN);
setsignal(SIGPIPE, handler);
setsignal(SIGQUIT, handler);
setsignal(SIGTTIN, handler);
#endif
gethostname(localhost, 256);
hep = gethostbyname(localhost);
printf("test host is %s\n", hep->h_name);
fflush(stdout);
/* switch (fork())
{
case -1: error
{
printf("failed to fork\n");
}
case 0: child
{
*/
fprintf(stdout, "Child stdout.\n");
fprintf(stderr, "Child stderr new.\n");
/*fclose(stdout);*/
/*fclose(stderr);*/
i=30;
while (i--){
#ifndef WIN32
int err = usleep (999999);
if (err) {
fprintf(stderr, "child sleep err %d\n", err);
return -1; //TODO: this was exiting with zero changed to -1
}
#else
Sleep(999);
#endif
printf("Child sleeping... (%d) \n", i);
fflush(stdout);
}
/*
}
default:
{
fprintf(stdout, "parent stdout.");
fprintf(stderr, "parent stderr x.");
fclose(stdout);/
fclose(stderr);/
return 0;
}
}
*/
return 0;
}
void
setjobctl(int on)
{
int i;
if (on == jobctl || rootshell == 0)
return;
if (on) {
if (ttyfd != -1)
close(ttyfd);
if ((ttyfd = open(_PATH_TTY, O_RDWR | O_CLOEXEC)) < 0) {
i = 0;
while (i <= 2 && !isatty(i))
i++;
if (i > 2 ||
(ttyfd = fcntl(i, F_DUPFD_CLOEXEC, 10)) < 0) {
jobctl_notty();
return;
}
}
if (ttyfd < 10) {
/*
* Keep our TTY file descriptor out of the way of
* the user's redirections.
*/
if ((i = fcntl(ttyfd, F_DUPFD_CLOEXEC, 10)) < 0) {
jobctl_notty();
return;
}
close(ttyfd);
ttyfd = i;
}
do { /* while we are in the background */
initialpgrp = tcgetpgrp(ttyfd);
if (initialpgrp < 0) {
jobctl_notty();
return;
}
if (initialpgrp != getpgrp()) {
if (!iflag) {
initialpgrp = -1;
jobctl_notty();
return;
}
kill(0, SIGTTIN);
continue;
}
} while (0);
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
setpgid(0, rootpid);
tcsetpgrp(ttyfd, rootpid);
} else { /* turning job control off */
setpgid(0, initialpgrp);
if (ttyfd >= 0) {
tcsetpgrp(ttyfd, initialpgrp);
close(ttyfd);
ttyfd = -1;
}
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
}
jobctl = on;
}
int main(int ac, char **av)
{
int ch, i=0;
pid_t pid;
FILE *fp;
uid_t uid;
#ifdef USE_THREAD
pthread_t tid;
pthread_attr_t attr;
struct rlimit rl;
rlim_t max_fd = (rlim_t)MAX_FD;
rlim_t save_fd = 0;
#endif
#ifdef USE_THREAD
threading = 1;
max_thread = MAX_THREAD;
#endif
max_child = MAX_CHILD;
cur_child = 0;
/* create service socket table (malloc) */
if (serv_init(NULL) < 0) {
msg_out(crit, "cannot malloc: %m\n");
exit(-1);
}
proxy_tbl = NULL;
proxy_tbl_ind = 0;
method_num = 0;
uid = getuid();
openlog(ident, LOG_PID | LOG_NDELAY, SYSLOGFAC);
while((ch = getopt(ac, av, "a:c:i:J:m:o:p:u:frstbwgIqvh?")) != -1)
switch (ch) {
case 'a':
if (optarg != NULL) {
for (i=0; i<sizeof method_tab; optarg++) {
if (*optarg == '\0')
break;
switch (*optarg) {
case 'p':
if ( uid != 0 ) {
/* process does not started by root */
msg_out(warn, "uid == %d (!=0),"
"user/pass auth will not work, ignored.\n",
uid);
break;
}
method_tab[i++] = S5AUSRPAS;
method_num++;
break;
case 'n':
method_tab[i++] = S5ANOAUTH;
method_num++;
break;
default:
break;
}
}
}
break;
case 'b':
bind_restrict = 0;
break;
case 'c':
if (optarg != NULL) {
config = strdup(optarg);
}
break;
case 'u':
if (optarg != NULL) {
pwdfile = strdup(optarg);
}
break;
case 'i':
if (optarg != NULL) {
if (serv_init(optarg) < 0) {
msg_out(warn, "cannot init server socket(-i %s): %m\n", optarg);
break;
}
}
break;
#ifdef SO_BINDTODEVICE
case 'J':
if (optarg != NULL) {
bindtodevice = strdup(optarg);
}
break;
#endif
case 'o':
if (optarg != NULL) {
idle_timeout = atol(optarg);
}
break;
case 'p':
if (optarg != NULL) {
pidfile = strdup(optarg);
}
break;
case 'm':
if (optarg != NULL) {
#ifdef USE_THREAD
max_thread = atoi(optarg);
#endif
max_child = atoi(optarg);
}
break;
case 't':
#ifdef USE_THREAD
threading = 0; /* threading disabled. */
#endif
break;
case 'g':
same_interface = 1;
break;
case 'f':
fg = 1;
break;
case 'r':
resolv_client = 1;
break;
case 's':
forcesyslog = 1;
break;
case 'w':
#ifdef HAVE_LIBWRAP
use_tcpwrap = 1;
#endif /* HAVE_LIBWRAP */
break;
case 'I':
inetd_mode = 1;
break;
case 'q':
be_quiet = 1;
break;
case 'v':
show_version();
exit(1);
case 'h':
case '?':
default:
usage();
}
ac -= optind;
av += optind;
if ((fp = fopen(config, "r")) != NULL) {
if (readconf(fp) != 0) {
/* readconf error */
exit(1);
}
fclose(fp);
}
if (inetd_mode) {
/* close all server socket if opened */
close_all_serv();
/* assuming that STDIN_FILENO handles bi-directional
*/
exit(inetd_service(STDIN_FILENO));
/* not reached */
}
if (serv_sock_ind == 0) { /* no valid ifs yet */
if (serv_init(":") < 0) { /* use default */
/* fatal */
msg_out(crit, "cannot open server socket\n");
exit(1);
}
}
#ifdef USE_THREAD
if ( ! threading ) {
#endif
if (queue_init() != 0) {
msg_out(crit, "cannot init signal queue\n");
exit(1);
}
#ifdef USE_THREAD
}
#endif
/* try changing working directory */
if ( chdir(WORKDIR0) != 0 )
if ( chdir(WORKDIR1) != 0 )
msg_out(norm, "giving up chdir to workdir");
if (!fg) {
/* force stdin/out/err allocate to /dev/null */
fclose(stdin);
fp = fopen("/dev/null", "w+");
if (fileno(fp) != STDIN_FILENO) {
msg_out(crit, "fopen: %m");
exit(1);
}
if (dup2(STDIN_FILENO, STDOUT_FILENO) == -1) {
msg_out(crit, "dup2-1: %m");
exit(1);
}
if (dup2(STDIN_FILENO, STDERR_FILENO) == -1) {
msg_out(crit, "dup2-2: %m");
exit(1);
}
switch(fork()) {
case -1:
msg_out(crit, "fork: %m");
exit(1);
case 0:
/* child */
pid = setsid();
if (pid == -1) {
msg_out(crit, "setsid: %m");
exit(1);
}
break;
default:
/* parent */
exit(0);
}
}
master_pid = getpid();
umask(S_IWGRP|S_IWOTH);
if ((fp = fopen(pidfile, "w")) != NULL) {
fprintf(fp, "%u\n", (unsigned)master_pid);
fchown(fileno(fp), PROCUID, PROCGID);
fclose(fp);
} else {
msg_out(warn, "cannot open pidfile %s", pidfile);
}
setsignal(SIGHUP, reload);
setsignal(SIGINT, SIG_IGN);
setsignal(SIGQUIT, SIG_IGN);
setsignal(SIGILL, SIG_IGN);
setsignal(SIGTRAP, SIG_IGN);
setsignal(SIGABRT, SIG_IGN);
#ifdef SIGEMT
setsignal(SIGEMT, SIG_IGN);
#endif
setsignal(SIGFPE, SIG_IGN);
setsignal(SIGBUS, SIG_IGN);
setsignal(SIGSEGV, SIG_IGN);
setsignal(SIGSYS, SIG_IGN);
setsignal(SIGPIPE, SIG_IGN);
setsignal(SIGALRM, SIG_IGN);
setsignal(SIGTERM, cleanup);
setsignal(SIGUSR1, SIG_IGN);
setsignal(SIGUSR2, SIG_IGN);
#ifdef SIGPOLL
setsignal(SIGPOLL, SIG_IGN);
#endif
setsignal(SIGVTALRM, SIG_IGN);
setsignal(SIGPROF, SIG_IGN);
setsignal(SIGXCPU, SIG_IGN);
setsignal(SIGXFSZ, SIG_IGN);
#ifdef USE_THREAD
if ( threading ) {
if (max_thread <= 0 || max_thread > THREAD_LIMIT) {
max_thread = THREAD_LIMIT;
}
/* resource limit is problem in threadig (e.g. Solaris:=64)*/
memset((caddr_t)&rl, 0, sizeof rl);
if (getrlimit(RLIMIT_NOFILE, &rl) != 0)
msg_out(warn, "getrlimit: %m");
else
save_fd = rl.rlim_cur;
if (rl.rlim_cur < (rlim_t)max_fd)
rl.rlim_cur = max_fd; /* willing to fix to max_fd */
if ( rl.rlim_cur != save_fd ) /* if rlim_cur is changed */
if (setrlimit(RLIMIT_NOFILE, &rl) != 0)
msg_out(warn, "cannot set rlimit(max_fd)");
setregid(0, PROCGID);
setreuid(0, PROCUID);
pthread_mutex_init(&mutex_select, NULL);
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
msg_out(norm, "Starting: MAX_TH(%d)", max_thread);
for (i=0; i<max_thread; i++) {
if (pthread_create(&tid, &attr,
(void *)&serv_loop, (void *)NULL) != 0)
exit(1);
}
main_thread = pthread_self(); /* store main thread ID */
for (;;) {
pause();
}
} else {
#endif
setsignal(SIGCHLD, reapchild);
setregid(0, PROCGID);
setreuid(0, PROCUID);
msg_out(norm, "Starting: MAX_CH(%d)", max_child);
serv_loop();
#ifdef USE_THREAD
}
#endif
return(0);
}
int serv_loop()
{
SOCKS_STATE state;
SOCK_INFO si;
CL_INFO client;
int cs;
fd_set readable;
int i, n, len;
int error;
pid_t pid;
memset(&state, 0, sizeof(state));
memset(&si, 0, sizeof(si));
memset(&client, 0, sizeof(client));
state.si = &si;
#ifdef USE_THREAD
if (threading) {
blocksignal(SIGHUP);
blocksignal(SIGINT);
blocksignal(SIGUSR1);
}
#endif
for (;;) {
readable = allsock;
MUTEX_LOCK(mutex_select);
n = select(maxsock+1, &readable, 0, 0, 0);
if (n <= 0) {
if (n < 0 && errno != EINTR) {
msg_out(warn, "select: %m");
}
MUTEX_UNLOCK(mutex_select);
continue;
}
#ifdef USE_THREAD
if ( ! threading ) {
#endif
/* handle any queued signal flags */
if (FD_ISSET(sig_queue[0], &readable)) {
if (ioctl(sig_queue[0], FIONREAD, &i) != 0) {
msg_out(crit, "ioctl: %m");
exit(-1);
}
while (--i >= 0) {
char c;
if (read(sig_queue[0], &c, 1) != 1) {
msg_out(crit, "read: %m");
exit(-1);
}
switch(c) {
case 'H': /* sighup */
reload();
break;
case 'C': /* sigchld */
reapchild();
break;
case 'T': /* sigterm */
cleanup();
break;
default:
break;
}
}
}
#ifdef USE_THREAD
}
#endif
for ( i = 0; i < serv_sock_ind; i++ ) {
if (FD_ISSET(serv_sock[i], &readable)) {
n--;
break;
}
}
if ( n < 0 || i >= serv_sock_ind ) {
MUTEX_UNLOCK(mutex_select);
continue;
}
len = SS_LEN;
cs = accept(serv_sock[i], &si.prc.addr.sa, (socklen_t *)&len);
si.prc.len = len;
if (cs < 0) {
if (errno == EINTR
#ifdef SOLARIS
|| errno == EPROTO
#endif
|| errno == EWOULDBLOCK
|| errno == ECONNABORTED) {
; /* ignore */
} else {
/* real accept error */
msg_out(warn, "accept: %m");
}
MUTEX_UNLOCK(mutex_select);
continue;
}
MUTEX_UNLOCK(mutex_select);
#ifdef USE_THREAD
if ( !threading ) {
#endif
if (max_child > 0 && cur_child >= max_child) {
msg_out(warn, "child: cur %d; exeedeing max(%d)",
cur_child, max_child);
close(cs);
continue;
}
#ifdef USE_THREAD
}
#endif
/* get downstream-side socket name */
len = SS_LEN;
getsockname(cs, &si.myc.addr.sa, (socklen_t *)&len);
si.myc.len = len;
error = getnameinfo(&si.prc.addr.sa, si.prc.len,
client.addr, sizeof(client.addr),
NULL, 0,
NI_NUMERICHOST);
if (resolv_client) {
error = getnameinfo(&si.prc.addr.sa, si.prc.len,
client.name, sizeof(client.name),
NULL, 0, 0);
msg_out(norm, "%s[%s] connected", client.name, client.addr);
} else {
msg_out(norm, "%s connected", client.addr);
strncpy(client.name, client.addr, sizeof(client.name));
}
i = validate_access(&client);
if (i < 1) {
/* access denied */
close(cs);
continue;
}
set_blocking(cs);
state.s = cs;
#ifdef USE_THREAD
if (!threading ) {
#endif
blocksignal(SIGHUP);
blocksignal(SIGCHLD);
pid = fork();
switch (pid) {
case -1: /* fork child failed */
break;
case 0: /* i am child */
for ( i = 0; i < serv_sock_ind; i++ ) {
close(serv_sock[i]);
}
setsignal(SIGCHLD, SIG_DFL);
setsignal(SIGHUP, SIG_DFL);
releasesignal(SIGCHLD);
releasesignal(SIGHUP);
error = proto_socks(&state);
if ( error == -1 ) {
close(state.s); /* may already be closed */
exit(1);
}
relay(&state);
exit(0);
default: /* may be parent */
proclist_add(pid);
break;
}
close(state.s);
releasesignal(SIGHUP);
releasesignal(SIGCHLD);
#ifdef USE_THREAD
} else {
error = proto_socks(&state);
if ( error == -1 ) {
close(state.s); /* may already be closed */
/* udp may be dynamically allocated */
if (state.sr.udp != NULL)
free(state.sr.udp);
continue;
}
relay(&state);
}
#endif
}
}
int
trapcmd(int argc, char **argv)
{
char *action;
char **ap;
int signo;
int errs = 0;
int printonly = 0;
ap = argv + 1;
if (argc == 2 && strcmp(*ap, "-l") == 0) {
printsignals();
return 0;
}
if (argc == 2 && strcmp(*ap, "-") == 0) {
for (signo = 0; signo < NSIG; signo++) {
if (trap[signo] == NULL)
continue;
INTOFF;
ckfree(trap[signo]);
trap[signo] = NULL;
if (signo != 0)
setsignal(signo, 0);
INTON;
}
return 0;
}
if (argc >= 2 && strcmp(*ap, "-p") == 0) {
printonly = 1;
ap++;
argc--;
}
if (argc > 1 && strcmp(*ap, "--") == 0) {
argc--;
ap++;
}
if (argc <= 1) {
int count;
if (printonly) {
for (count = 0, signo = 0 ; signo < NSIG ; signo++)
if (trap[signo] == NULL) {
if (count == 0)
out1str("trap -- -");
out1fmt(" %s", trap_signame(signo));
/* oh! unlucky 13 */
if (++count >= 13) {
out1str("\n");
count = 0;
}
}
if (count)
out1str("\n");
}
for (count = 0, signo = 0 ; signo < NSIG ; signo++)
if (trap[signo] != NULL && trap[signo][0] == '\0') {
if (count == 0)
out1str("trap -- ''");
out1fmt(" %s", trap_signame(signo));
/*
* the prefix is 10 bytes, with 4 byte
* signal names (common) we have room in
* the 70 bytes left on a normal line for
* 70/(4+1) signals, that's 14, but to
* allow for the occasional longer sig name
* we output one less...
*/
if (++count >= 13) {
out1str("\n");
count = 0;
}
}
if (count)
out1str("\n");
for (signo = 0 ; signo < NSIG ; signo++)
if (trap[signo] != NULL && trap[signo][0] != '\0') {
out1str("trap -- ");
print_quoted(trap[signo]);
out1fmt(" %s\n", trap_signame(signo));
}
return 0;
}
action = NULL;
if (!printonly && !is_number(*ap)) {
if ((*ap)[0] == '-' && (*ap)[1] == '\0')
ap++; /* reset to default */
else
action = *ap++; /* can be '' for "ignore" */
argc--;
}
if (argc < 2) { /* there must be at least 1 condition */
out2str("Usage: trap [-l]\n"
" trap -p [condition ...]\n"
" trap action condition ...\n"
" trap N condition ...\n");
return 2;
}
while (*ap) {
signo = signame_to_signum(*ap);
if (signo < 0 || signo >= NSIG) {
/* This is not a fatal error, so sayeth posix */
outfmt(out2, "trap: '%s' bad condition\n", *ap);
errs = 1;
ap++;
continue;
}
ap++;
if (printonly) {
out1str("trap -- ");
if (trap[signo] == NULL)
out1str("-");
else
print_quoted(trap[signo]);
out1fmt(" %s\n", trap_signame(signo));
continue;
}
INTOFF;
if (action)
action = savestr(action);
if (trap[signo])
ckfree(trap[signo]);
trap[signo] = action;
if (signo != 0)
setsignal(signo, 0);
INTON;
}
return errs;
}
int
main(int argc, char *argv[])
{
#if EV_MULTIPLICITY
lem_loop = ev_default_loop(LEM_LOOPFLAGS);
if (lem_loop == NULL) {
#else
if (!ev_default_loop(LEM_LOOPFLAGS)) {
#endif
lem_log_error("lem: error initializing event loop");
return EXIT_FAILURE;
}
if (setsignal(SIGPIPE, SIG_IGN, 0)
#if !EV_CHILD_ENABLE
|| setsignal(SIGCHLD, SIG_DFL, SA_NOCLDSTOP | SA_NOCLDWAIT)
#endif
)
goto error;
/* create main Lua state */
L = luaL_newstate();
if (L == NULL) {
lem_log_error("lem: error initializing Lua state");
goto error;
}
luaL_openlibs(L);
/* push thread table */
lua_newtable(L);
/* initialize runqueue */
ev_idle_init(&rq.w, runqueue_pop);
ev_idle_start(LEM_ &rq.w);
rq.queue = lem_xmalloc(LEM_INITIAL_QUEUESIZE
* sizeof(struct lem_runqueue_slot));
rq.first = rq.last = 0;
rq.mask = LEM_INITIAL_QUEUESIZE - 1;
/* initialize threadpool */
if (pool_init()) {
lem_log_error("lem: error initializing threadpool");
goto error;
}
/* load file */
if (queue_file(argc, argv, 1))
goto error;
/* start the mainloop */
ev_loop(LEM_ 0);
lem_debug("event loop exited");
/* if there is an error message left on L print it */
if (lua_type(L, -1) == LUA_TSTRING)
lem_log_error("lem: %s", lua_tostring(L, -1));
/* shutdown Lua */
lua_close(L);
/* free runqueue */
free(rq.queue);
/* destroy loop */
#if EV_MULTIPLICITY
ev_loop_destroy(lem_loop);
#else
ev_default_destroy();
#endif
lem_debug("Bye %s", exit_status == EXIT_SUCCESS ? "o/" : ":(");
return exit_status;
error:
if (L)
lua_close(L);
if (rq.queue)
free(rq.queue);
#if EV_MULTIPLICITY
ev_loop_destroy(lem_loop);
#else
ev_default_destroy();
#endif
return EXIT_FAILURE;
}
void
setjobctl(int on)
{
int i;
if (on == jobctl || rootshell == 0)
return;
if (on) {
if (ttyfd != -1)
close(ttyfd);
if ((ttyfd = open(_PATH_TTY, O_RDWR)) < 0) {
i = 0;
while (i <= 2 && !isatty(i))
i++;
if (i > 2 || (ttyfd = fcntl(i, F_DUPFD, 10)) < 0)
goto out;
}
if (ttyfd < 10) {
/*
* Keep our TTY file descriptor out of the way of
* the user's redirections.
*/
if ((i = fcntl(ttyfd, F_DUPFD, 10)) < 0) {
close(ttyfd);
ttyfd = -1;
goto out;
}
close(ttyfd);
ttyfd = i;
}
if (fcntl(ttyfd, F_SETFD, FD_CLOEXEC) < 0) {
close(ttyfd);
ttyfd = -1;
goto out;
}
do { /* while we are in the background */
initialpgrp = tcgetpgrp(ttyfd);
if (initialpgrp < 0) {
out: out2str("sh: can't access tty; job control turned off\n");
mflag = 0;
return;
}
if (initialpgrp == -1)
initialpgrp = getpgrp();
else if (initialpgrp != getpgrp()) {
killpg(0, SIGTTIN);
continue;
}
} while (0);
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
setpgid(0, rootpid);
tcsetpgrp(ttyfd, rootpid);
} else { /* turning job control off */
setpgid(0, initialpgrp);
tcsetpgrp(ttyfd, initialpgrp);
close(ttyfd);
ttyfd = -1;
setsignal(SIGTSTP);
setsignal(SIGTTOU);
setsignal(SIGTTIN);
}
jobctl = on;
}
int
trapcmd(shinstance *psh, int argc, char **argv)
{
char *action;
char **ap;
int signo;
#ifndef HAVE_SYS_SIGNAME
init_sys_signame();
#endif
if (argc <= 1) {
for (signo = 0 ; signo <= NSIG ; signo++)
if (psh->trap[signo] != NULL) {
out1fmt(psh, "trap -- ");
print_quoted(psh, psh->trap[signo]);
out1fmt(psh, " %s\n",
(signo) ? sys_signame[signo] : "EXIT");
}
return 0;
}
ap = argv + 1;
action = NULL;
if (strcmp(*ap, "--") == 0)
if (*++ap == NULL)
return 0;
if (signame_to_signum(psh, *ap) == -1) {
if ((*ap)[0] == '-') {
if ((*ap)[1] == '\0')
ap++;
else if ((*ap)[1] == 'l' && (*ap)[2] == '\0') {
printsignals(psh);
return 0;
}
else
error(psh, "bad option %s\n", *ap);
}
else
action = *ap++;
}
while (*ap) {
if (is_number(*ap))
signo = number(psh, *ap);
else
signo = signame_to_signum(psh, *ap);
if (signo < 0 || signo > NSIG)
error(psh, "%s: bad trap", *ap);
INTOFF;
if (action)
action = savestr(psh, action);
if (psh->trap[signo])
ckfree(psh, psh->trap[signo]);
psh->trap[signo] = action;
if (signo != 0)
setsignal(psh, signo, 0);
INTON;
ap++;
}
return 0;
}
SH_NORETURN_1 void
shell_main(shinstance *psh, int argc, char **argv)
{
struct jmploc jmploc;
struct stackmark smark;
volatile int state;
char *shinit;
state = 0;
if (setjmp(jmploc.loc)) {
/*
* When a shell procedure is executed, we raise the
* exception EXSHELLPROC to clean up before executing
* the shell procedure.
*/
switch (psh->exception) {
case EXSHELLPROC:
psh->rootpid = /*getpid()*/ psh->pid;
psh->rootshell = 1;
psh->minusc = NULL;
state = 3;
break;
case EXEXEC:
psh->exitstatus = psh->exerrno;
break;
case EXERROR:
psh->exitstatus = 2;
break;
default:
break;
}
if (psh->exception != EXSHELLPROC) {
if (state == 0 || iflag(psh) == 0 || ! psh->rootshell)
exitshell(psh, psh->exitstatus);
}
reset(psh);
if (psh->exception == EXINT
#if ATTY
&& (! attyset(psh) || equal(termval(psh), "emacs"))
#endif
) {
out2c(psh, '\n');
flushout(&psh->errout);
}
popstackmark(psh, &smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
psh->handler = &jmploc;
psh->rootpid = /*getpid()*/ psh->pid;
psh->rootshell = 1;
#ifdef DEBUG
#if DEBUG == 2
debug(psh) = 1;
#endif
opentrace(psh);
trputs(psh, "Shell args: "); trargs(psh, argv);
#endif
init(psh);
setstackmark(psh, &smark);
procargs(psh, argc, argv);
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile(psh, "/etc/profile");
state1:
state = 2;
read_profile(psh, ".profile");
}
state2:
state = 3;
if (sh_getuid(psh) == sh_geteuid(psh) && sh_getgid(psh) == sh_getegid(psh)) {
if ((shinit = lookupvar(psh, "ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(psh, shinit);
}
}
state3:
state = 4;
if (sflag(psh) == 0 || psh->minusc) {
static int sigs[] = {
SIGINT, SIGQUIT, SIGHUP,
#ifdef SIGTSTP
SIGTSTP,
#endif
SIGPIPE
};
#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
unsigned i;
for (i = 0; i < SIGSSIZE; i++)
setsignal(psh, sigs[i], 0);
}
if (psh->minusc)
evalstring(psh, psh->minusc, 0);
if (sflag(psh) || psh->minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(psh, 1);
}
exitshell(psh, psh->exitstatus);
/* NOTREACHED */
}
void relay_udp(SOCKS_STATE *state)
{
fd_set rfds;
int nfds, sfd;
struct timeval tv;
struct timezone tz;
ssize_t wc;
rlyinfo ri;
int done;
u_long max_count = idle_timeout;
u_long timeout_count;
struct sockaddr_storage ss;
LOGINFO li;
memset(&ri, 0, sizeof(ri));
memset(&li, 0, sizeof(li));
ri.ss = (struct sockaddr *)&ss;
ri.flags = 0;
ri.nr = BUFSIZE-sizeof(UDPH);
setsignal(SIGALRM, timeout);
gettimeofday(&li.start, &tz);
li.bc = li.upl = li.dnl = 0;
timeout_count = 0;
for (;;) {
FD_ZERO(&rfds);
FD_SET(state->s, &rfds); FD_SET(state->sr.udp->d, &rfds);
nfds = MAX(state->s, state->sr.udp->d);
if (state->r >= 0) {
FD_SET(state->r, &rfds);
nfds = MAX(nfds, state->r);
}
if (state->sr.udp->u >= 0) {
FD_SET(state->sr.udp->u, &rfds);
nfds = MAX(nfds, state->sr.udp->u);
}
done = 0;
/* idle timeout related setting. */
tv.tv_sec = 60; tv.tv_usec = 0; /* unit = 1 minute. */
tz.tz_minuteswest = 0; tz.tz_dsttime = 0;
sfd = select(nfds+1, &rfds, 0, 0, &tv);
if (sfd > 0) {
/* UDP channels */
/* in case of UDP, wc == 0 does not mean EOF (??) */
if (FD_ISSET(state->sr.udp->d, &rfds)) {
ri.from = state->sr.udp->d; ri.to = state->sr.udp->u;
ri.dir = UP;
if ((wc = forward_udp(&ri, state->sr.udp, state->rtbl.rl_meth)) < 0)
done++;
else
{
li.bc += wc; li.upl += wc;
if (log_tmp_transfer_callback) log_tmp_transfer_callback(state->si, &li, wc, 0);
}
FD_CLR(state->sr.udp->d, &rfds);
}
if (state->sr.udp->u >= 0 && FD_ISSET(state->sr.udp->u, &rfds)) {
ri.from = state->sr.udp->u; ri.to = state->sr.udp->d;
ri.dir = DOWN;
if ((wc = forward_udp(&ri, state->sr.udp, state->rtbl.rl_meth)) < 0)
done++;
else
{
li.bc += wc; li.dnl += wc;
if (log_tmp_transfer_callback) log_tmp_transfer_callback(state->si, &li, wc, 0);
}
FD_CLR(state->sr.udp->d, &rfds);
}
/* packets on TCP channel may indicate
termination of UDP assoc.
*/
if (FD_ISSET(state->s, &rfds)) {
ri.from = state->s; ri.to = state->r; ri.flags = 0;
if ((wc = forward(&ri)) <= 0)
done++;
FD_CLR(state->s, &rfds);
}
if (FD_ISSET(state->r >= 0 && state->r, &rfds)) {
ri.from = state->r; ri.to = state->s; ri.flags = 0;
if ((wc = forward(&ri)) <= 0)
done++;
FD_CLR(state->r, &rfds);
}
if (done > 0)
break;
} else if (sfd < 0) {
if (errno != EINTR)
break;
} else { /* sfd == 0 */
if (max_count != 0) {
timeout_count++;
if (timeout_count > max_count)
break;
}
}
}
gettimeofday(&li.end, &tz);
/* getsockname for logging */
state->sr.udp->si.myc.len = SS_LEN;
getsockname(state->sr.udp->d,
&state->sr.udp->si.myc.addr.sa,
(socklen_t *)&state->sr.udp->si.myc.len);
if (state->sr.udp->u >= 0) {
state->sr.udp->si.mys.len = SS_LEN;
getsockname(state->sr.udp->u,
&state->sr.udp->si.mys.addr.sa,
(socklen_t *)&state->sr.udp->si.mys.len);
}
log_transfer(&state->sr.udp->si, &li);
close(state->s);
if (state->r >= 0)
close(state->r);
close(state->sr.udp->d);
if (state->sr.udp->u >= 0)
close(state->sr.udp->u);
if (state->sr.udp != NULL)
free(state->sr.udp);
}
int
main(int argc, char **argv)
{
int cnt, op, i, done = 0;
bpf_u_int32 localnet, netmask;
char *cp, *cmdbuf, *device;
struct bpf_program fcode;
void (*oldhandler)(int);
u_char *pcap_userdata;
char ebuf[PCAP_ERRBUF_SIZE];
cnt = -1;
device = NULL;
if ((cp = strrchr(argv[0], '/')) != NULL)
program_name = cp + 1;
else
program_name = argv[0];
opterr = 0;
while ((i = getopt(argc, argv, "pa")) != -1)
{
switch (i)
{
case 'p':
pflag = 1;
break;
case 'a':
aflag = 1;
break;
case '?':
default:
done = 1;
break;
}
if (done) break;
}
if (argc > (optind)) cmdbuf = copy_argv(&argv[optind]);
else cmdbuf = "";
if (device == NULL) {
device = pcap_lookupdev(ebuf);
if (device == NULL)
error("%s", ebuf);
}
pd = pcap_open_live(device, snaplen, 1, 1000, ebuf);
if (pd == NULL)
error("%s", ebuf);
i = pcap_snapshot(pd);
if (snaplen < i) {
warning("snaplen raised from %d to %d", snaplen, i);
snaplen = i;
}
if (pcap_lookupnet(device, &localnet, &netmask, ebuf) < 0) {
localnet = 0;
netmask = 0;
warning("%s", ebuf);
}
/*
* Let user own process after socket has been opened.
*/
setuid(getuid());
if (pcap_compile(pd, &fcode, cmdbuf, 1, netmask) < 0)
error("%s", pcap_geterr(pd));
(void)setsignal(SIGTERM, program_ending);
(void)setsignal(SIGINT, program_ending);
/* Cooperate with nohup(1) */
if ((oldhandler = setsignal(SIGHUP, program_ending)) != SIG_DFL)
(void)setsignal(SIGHUP, oldhandler);
if (pcap_setfilter(pd, &fcode) < 0)
error("%s", pcap_geterr(pd));
pcap_userdata = 0;
(void)fprintf(stderr, "%s: listening on %s\n", program_name, device);
if (pcap_loop(pd, cnt, raw_print, pcap_userdata) < 0) {
(void)fprintf(stderr, "%s: pcap_loop: %s\n",
program_name, pcap_geterr(pd));
exit(1);
}
pcap_close(pd);
exit(0);
}
int
main(int argc, char **argv)
{
struct jmploc jmploc;
struct stackmark smark;
volatile int state;
char *shinit;
setlocale(LC_ALL, "");
/* Just a --version for show. */
if (argc > 1
&& argv[1][0] == '-'
&& argv[1][1] == '-') {
if (!strcmp(&argv[1][2], "version")) {
printf("kmk_ash - kBuild version %d.%d.%d\n",
KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR, KBUILD_VERSION_PATCH);
return 0;
}
if (!strcmp(&argv[1][2], "help")) {
printf("usage: kmk_ash [-aCefnuvxIimqVEb] [+aCefnuvxIimqVEb] [-o option_name]\n"
" [+o option_name] [command_file [argument ...]]\n"
" or: kmk_ash -c [-aCefnuvxIimqVEb] [+aCefnuvxIimqVEb] [-o option_name]\n"
" [+o option_name] command_string [command_name [argument ...]]\n"
" or: kmk_ash -s [-aCefnuvxIimqVEb] [+aCefnuvxIimqVEb] [-o option_name]\n"
" [+o option_name] [argument ...]\n"
" or: kmk_ash --help\n"
" or: kmk_ash --version\n",
argv[0], argv[0], argv[0], argv[0], argv[0]);
return 0;
}
}
#if PROFILE
monitor(4, etext, profile_buf, sizeof profile_buf, 50);
#endif
state = 0;
if (setjmp(jmploc.loc)) {
/*
* When a shell procedure is executed, we raise the
* exception EXSHELLPROC to clean up before executing
* the shell procedure.
*/
switch (exception) {
case EXSHELLPROC:
rootpid = getpid();
rootshell = 1;
minusc = NULL;
state = 3;
break;
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (exception != EXSHELLPROC) {
if (state == 0 || iflag == 0 || ! rootshell)
exitshell(exitstatus);
}
reset();
if (exception == EXINT
#if ATTY
&& (! attyset() || equal(termval(), "emacs"))
#endif
) {
out2c('\n');
flushout(&errout);
}
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &jmploc;
#ifdef DEBUG
#if DEBUG == 2
debug = 1;
#endif
opentrace();
trputs("Shell args: "); trargs(argv);
#endif
rootpid = getpid();
rootshell = 1;
#ifdef _MSC_VER
{
extern void init_syntax(void);
init_syntax();
}
#endif
init();
setstackmark(&smark);
procargs(argc, argv);
if (argv[0] && argv[0][0] == '-') {
state = 1;
#ifndef KMK
read_profile("/etc/profile");
#endif
state1:
state = 2;
#ifndef KMK
read_profile(".profile");
#endif
}
state2:
state = 3;
#ifndef KMK
if (getuid() == geteuid() && getgid() == getegid()) {
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(shinit);
}
}
#endif
state3:
state = 4;
if (sflag == 0 || minusc) {
static int sigs[] = {
SIGINT, SIGQUIT, SIGHUP,
#ifdef SIGTSTP
SIGTSTP,
#endif
SIGPIPE
};
#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
int i;
for (i = 0; i < SIGSSIZE; i++)
setsignal(sigs[i], 0);
}
if (minusc)
evalstring(minusc, 0);
if (sflag || minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(1);
}
#if PROFILE
monitor(0);
#endif
exitshell(exitstatus);
/* NOTREACHED */
}
int
trapcmd(int argc, char **argv)
{
char *action;
char **ap;
int signo;
if (argc <= 1) {
for (signo = 0 ; signo <= NSIG ; signo++)
if (trap[signo] != NULL) {
out1fmt("trap -- ");
print_quoted(trap[signo]);
out1fmt(" %s\n",
(signo) ? sys_signame[signo] : "EXIT");
}
return 0;
}
ap = argv + 1;
action = NULL;
if (strcmp(*ap, "--") == 0)
if (*++ap == NULL)
return 0;
if (signame_to_signum(*ap) == -1) {
if ((*ap)[0] == '-') {
if ((*ap)[1] == '\0')
ap++;
else if ((*ap)[1] == 'l' && (*ap)[2] == '\0') {
printsignals();
return 0;
}
else
error("bad option %s\n", *ap);
}
else
action = *ap++;
}
while (*ap) {
if (is_number(*ap))
signo = number(*ap);
else
signo = signame_to_signum(*ap);
if (signo < 0 || signo > NSIG)
error("%s: bad trap", *ap);
INTOFF;
if (action)
action = savestr(action);
if (trap[signo])
ckfree(trap[signo]);
trap[signo] = action;
if (signo != 0)
setsignal(signo, 0);
INTON;
ap++;
}
return 0;
}
void relay(int cs, int ss)
{
fd_set rfds, xfds;
int nfds, sfd;
struct timeval tv, ts, ots, elp;
struct timezone tz;
ssize_t wc;
rlyinfo ri;
int done;
u_long max_count = idle_timeout;
u_long timeout_count;
loginfo li;
memset(&ri, 0, sizeof(ri));
ri.nr = BUFSIZE;
memset(&li, 0, sizeof(li));
set_sock_info(&li, cs, ss);
nfds = (ss > cs ? ss : cs);
setsignal(SIGALRM, timeout);
gettimeofday(&ots, &tz);
li.bc = li.upl = li.dnl = 0; ri.oob = 0; timeout_count = 0;
for (;;) {
FD_ZERO(&rfds);
FD_SET(cs, &rfds); FD_SET(ss, &rfds);
if (ri.oob == 0) {
FD_ZERO(&xfds);
FD_SET(cs, &xfds); FD_SET(ss, &xfds);
}
done = 0;
/* idle timeout related setting. */
tv.tv_sec = 60; tv.tv_usec = 0; /* unit = 1 minute. */
tz.tz_minuteswest = 0; tz.tz_dsttime = 0;
sfd = select(nfds+1, &rfds, 0, &xfds, &tv);
if (sfd > 0) {
if (FD_ISSET(ss, &rfds)) {
ri.from = ss; ri.to = cs; ri.oob = 0;
if ((wc = forward(&ri)) <= 0)
done++;
else
li.bc += wc; li.dnl += wc;
FD_CLR(ss, &rfds);
}
if (FD_ISSET(ss, &xfds)) {
ri.from = ss; ri.to = cs; ri.oob = 1;
if ((wc = forward(&ri)) <= 0)
done++;
else
li.bc += wc; li.dnl += wc;
FD_CLR(ss, &xfds);
}
if (FD_ISSET(cs, &rfds)) {
ri.from = cs; ri.to = ss; ri.oob = 0;
if ((wc = forward(&ri)) <= 0)
done++;
else
li.bc += wc; li.upl += wc;
FD_CLR(cs, &rfds);
}
if (FD_ISSET(cs, &xfds)) {
ri.from = cs; ri.to = ss; ri.oob = 1;
if ((wc = forward(&ri)) <= 0)
done++;
else
li.bc += wc; li.upl += wc;
FD_CLR(cs, &xfds);
}
if (done > 0)
break;
} else if (sfd < 0) {
if (errno != EINTR)
break;
} else { /* sfd == 0 */
if (max_count != 0) {
timeout_count++;
if (timeout_count > max_count)
break;
}
}
}
gettimeofday(&ts, &tz);
if (ts.tv_usec < ots.tv_usec) {
ts.tv_sec--; ts.tv_usec += 1000000;
}
elp.tv_sec = ts.tv_sec - ots.tv_sec;
elp.tv_usec = ts.tv_usec - ots.tv_usec;
li.elp = elp;
log_transfer(&li);
close(ss);
close(cs);
}
void relay_tcp(SOCKS_STATE *state)
{
fd_set rfds, xfds;
int nfds, sfd;
struct timeval tv;
struct timezone tz;
ssize_t wc;
rlyinfo ri;
int done;
u_long max_count = idle_timeout;
u_long timeout_count;
LOGINFO li;
memset(&ri, 0, sizeof(ri));
memset(&li, 0, sizeof(li));
ri.ss = (struct sockaddr *)NULL;
ri.len = 0;
ri.nr = BUFSIZE;
nfds = MAX(state->r, state->s);
setsignal(SIGALRM, timeout);
gettimeofday(&li.start, &tz);
li.bc = li.upl = li.dnl = 0;
ri.flags = 0; timeout_count = 0;
for (;;) {
FD_ZERO(&rfds);
FD_SET(state->s, &rfds); FD_SET(state->r, &rfds);
if (ri.flags == 0) {
FD_ZERO(&xfds);
FD_SET(state->s, &xfds); FD_SET(state->r, &xfds);
}
done = 0;
/* idle timeout related setting. */
tv.tv_sec = 60; tv.tv_usec = 0; /* unit = 1 minute. */
tz.tz_minuteswest = 0; tz.tz_dsttime = 0;
sfd = select(nfds+1, &rfds, 0, &xfds, &tv);
if (sfd > 0) {
if (FD_ISSET(state->r, &rfds)) {
ri.from = state->r; ri.to = state->s; ri.flags = 0;
if ((wc = forward(&ri)) <= 0)
done++;
else
{
li.bc += wc; li.dnl += wc;
if (log_tmp_transfer_callback) log_tmp_transfer_callback(state->si, &li, wc, 0);
}
FD_CLR(state->r, &rfds);
}
if (FD_ISSET(state->r, &xfds)) {
ri.from = state->r; ri.to = state->s; ri.flags = MSG_OOB;
if ((wc = forward(&ri)) <= 0)
done++;
else
{
li.bc += wc; li.dnl += wc;
if (log_tmp_transfer_callback) log_tmp_transfer_callback(state->si, &li, wc, 0);
}
FD_CLR(state->r, &xfds);
}
if (FD_ISSET(state->s, &rfds)) {
ri.from = state->s; ri.to = state->r; ri.flags = 0;
if ((wc = forward(&ri)) <= 0)
done++;
else
{
li.bc += wc; li.upl += wc;
if (log_tmp_transfer_callback) log_tmp_transfer_callback(state->si, &li, wc, 0);
}
FD_CLR(state->s, &rfds);
}
if (FD_ISSET(state->s, &xfds)) {
ri.from = state->s; ri.to = state->r; ri.flags = MSG_OOB;
if ((wc = forward(&ri)) <= 0)
done++;
else
{
li.bc += wc; li.upl += wc;
if (log_tmp_transfer_callback) log_tmp_transfer_callback(state->si, &li, wc, 0);
}
FD_CLR(state->s, &xfds);
}
if (done > 0)
break;
} else if (sfd < 0) {
if (errno != EINTR)
break;
} else { /* sfd == 0 */
if (max_count != 0) {
timeout_count++;
if (timeout_count > max_count)
break;
}
}
}
gettimeofday(&li.end, &tz);
log_transfer(state->si, &li);
close(state->r);
close(state->s);
}
int
main(int argc, char **argv)
{
struct stackmark smark;
volatile int state;
char *shinit;
uid_t uid;
gid_t gid;
uid = getuid();
gid = getgid();
max_user_fd = fcntl(0, F_MAXFD);
if (max_user_fd < 2)
max_user_fd = 2;
setlocale(LC_ALL, "");
posix = getenv("POSIXLY_CORRECT") != NULL;
#if PROFILE
monitor(4, etext, profile_buf, sizeof profile_buf, 50);
#endif
state = 0;
if (setjmp(main_handler.loc)) {
/*
* When a shell procedure is executed, we raise the
* exception EXSHELLPROC to clean up before executing
* the shell procedure.
*/
switch (exception) {
case EXSHELLPROC:
rootpid = getpid();
rootshell = 1;
minusc = NULL;
state = 3;
break;
case EXEXEC:
exitstatus = exerrno;
break;
case EXERROR:
exitstatus = 2;
break;
default:
break;
}
if (exception != EXSHELLPROC) {
if (state == 0 || iflag == 0 || ! rootshell ||
exception == EXEXIT)
exitshell(exitstatus);
}
reset();
if (exception == EXINT) {
out2c('\n');
flushout(&errout);
}
popstackmark(&smark);
FORCEINTON; /* enable interrupts */
if (state == 1)
goto state1;
else if (state == 2)
goto state2;
else if (state == 3)
goto state3;
else
goto state4;
}
handler = &main_handler;
#ifdef DEBUG
#if DEBUG >= 2
debug = 1; /* this may be reset by procargs() later */
#endif
opentrace();
trputs("Shell args: "); trargs(argv);
#if DEBUG >= 3
set_debug(((DEBUG)==3 ? "_@" : "++"), 1);
#endif
#endif
rootpid = getpid();
rootshell = 1;
init();
initpwd();
setstackmark(&smark);
procargs(argc, argv);
/*
* Limit bogus system(3) or popen(3) calls in setuid binaries,
* by requiring the -p flag
*/
if (!pflag && (uid != geteuid() || gid != getegid())) {
setuid(uid);
setgid(gid);
/* PS1 might need to be changed accordingly. */
choose_ps1();
}
if (argv[0] && argv[0][0] == '-') {
state = 1;
read_profile("/etc/profile");
state1:
state = 2;
read_profile(".profile");
}
state2:
state = 3;
if ((iflag || !posix) &&
getuid() == geteuid() && getgid() == getegid()) {
struct stackmark env_smark;
setstackmark(&env_smark);
if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
state = 3;
read_profile(expandenv(shinit));
}
popstackmark(&env_smark);
}
state3:
state = 4;
line_number = 1; /* undo anything from profile files */
if (sflag == 0 || minusc) {
static int sigs[] = {
SIGINT, SIGQUIT, SIGHUP,
#ifdef SIGTSTP
SIGTSTP,
#endif
SIGPIPE
};
#define SIGSSIZE (sizeof(sigs)/sizeof(sigs[0]))
size_t i;
for (i = 0; i < SIGSSIZE; i++)
setsignal(sigs[i], 0);
}
if (minusc)
evalstring(minusc, sflag ? 0 : EV_EXIT);
if (sflag || minusc == NULL) {
state4: /* XXX ??? - why isn't this before the "if" statement */
cmdloop(1);
if (iflag) {
out2str("\n");
flushout(&errout);
}
}
#if PROFILE
monitor(0);
#endif
line_number = plinno;
exitshell(exitstatus);
/* NOTREACHED */
}
