/* pass_on()
* Is the work loop of the logger. Selects on the pipe to the to_erl
* program erlang. If input arrives from to_erl it is passed on to
* erlang.
*/
static void pass_on(pid_t childpid)
{
int len;
fd_set readfds;
fd_set writefds;
fd_set* writefds_ptr;
struct timeval timeout;
time_t last_activity;
char buf[BUFSIZ];
char log_alive_buffer[ALIVE_BUFFSIZ+1];
int lognum;
int rfd, wfd=0, lfd=0;
int maxfd;
int ready;
int got_some = 0; /* from to_erl */
/* Open the to_erl pipe for reading.
* We can't open the writing side because nobody is reading and
* we'd either hang or get an error.
*/
if ((rfd = sf_open(fifo2, O_RDONLY|DONT_BLOCK_PLEASE, 0)) < 0) {
ERRNO_ERR1(LOG_ERR,"Could not open FIFO '%s' for reading.", fifo2);
exit(1);
}
#ifdef DEBUG
status("run_erl: %s opened for reading\n", fifo2);
#endif
/* Open the log file */
lognum = find_next_log_num();
lfd = open_log(lognum, O_RDWR|O_APPEND|O_CREAT|O_SYNC);
/* Enter the work loop */
while (1) {
int exit_status;
maxfd = MAX(rfd, mfd);
maxfd = MAX(wfd, maxfd);
FD_ZERO(&readfds);
FD_SET(rfd, &readfds);
FD_SET(mfd, &readfds);
FD_ZERO(&writefds);
if (outbuf_size() == 0) {
writefds_ptr = NULL;
} else {
FD_SET(wfd, &writefds);
writefds_ptr = &writefds;
}
time(&last_activity);
timeout.tv_sec = log_alive_minutes*60; /* don't assume old BSD bug */
timeout.tv_usec = 0;
ready = select(maxfd + 1, &readfds, writefds_ptr, NULL, &timeout);
if (ready < 0) {
if (errno == EINTR) {
if (waitpid(childpid, &exit_status, WNOHANG) == childpid) {
/*
* The Erlang emulator has terminated. Give us some more
* time to write out any pending data before we terminate too.
*/
alarm(5);
}
FD_ZERO(&readfds);
FD_ZERO(&writefds);
} else {
/* Some error occured */
ERRNO_ERR0(LOG_ERR,"Error in select.");
exit(1);
}
} else {
time_t now;
if (waitpid(childpid, &exit_status, WNOHANG) == childpid) {
alarm(5);
FD_ZERO(&readfds);
FD_ZERO(&writefds);
}
/* Check how long time we've been inactive */
time(&now);
if(!ready || now - last_activity > log_activity_minutes*60) {
/* Either a time out: 15 minutes without action, */
/* or something is coming in right now, but it's a long time */
/* since last time, so let's write a time stamp this message */
struct tm *tmptr;
if (log_alive_in_gmt) {
tmptr = gmtime(&now);
} else {
tmptr = localtime(&now);
}
if (!strftime(log_alive_buffer, ALIVE_BUFFSIZ, log_alive_format,
tmptr)) {
strn_cpy(log_alive_buffer, sizeof(log_alive_buffer),
"(could not format time in 256 positions "
"with current format string.)");
}
log_alive_buffer[ALIVE_BUFFSIZ] = '\0';
sn_printf(buf, sizeof(buf), "\n===== %s%s\n",
ready?"":"ALIVE ", log_alive_buffer);
write_to_log(&lfd, &lognum, buf, strlen(buf));
}
}
/*
* Write any pending output first.
*/
if (FD_ISSET(wfd, &writefds)) {
int written;
char* buf = outbuf_first();
len = outbuf_size();
written = sf_write(wfd, buf, len);
if (written < 0 && errno == EAGAIN) {
/*
* Nothing was written - this is really strange because
* select() told us we could write. Ignore.
*/
} else if (written < 0) {
/*
* A write error. Assume that to_erl has terminated.
*/
clear_outbuf();
sf_close(wfd);
wfd = 0;
} else {
/* Delete the written part (or all) from the buffer. */
outbuf_delete(written);
}
}
/*
* Read master pty and write to FIFO.
*/
if (FD_ISSET(mfd, &readfds)) {
#ifdef DEBUG
status("Pty master read; ");
#endif
if ((len = sf_read(mfd, buf, BUFSIZ)) <= 0) {
sf_close(rfd);
if(wfd) sf_close(wfd);
sf_close(mfd);
unlink(fifo1);
unlink(fifo2);
if (len < 0) {
if(errno == EIO)
ERROR0(LOG_ERR,"Erlang closed the connection.");
else
ERRNO_ERR0(LOG_ERR,"Error in reading from terminal");
exit(1);
}
exit(0);
}
write_to_log(&lfd, &lognum, buf, len);
/*
* Save in the output queue.
*/
if (wfd) {
outbuf_append(buf, len);
}
}
/*
* Read from FIFO, write to master pty
*/
if (FD_ISSET(rfd, &readfds)) {
#ifdef DEBUG
status("FIFO read; ");
#endif
if ((len = sf_read(rfd, buf, BUFSIZ)) < 0) {
sf_close(rfd);
if(wfd) sf_close(wfd);
sf_close(mfd);
unlink(fifo1);
unlink(fifo2);
ERRNO_ERR0(LOG_ERR,"Error in reading from FIFO.");
exit(1);
}
if(!len) {
/* to_erl closed its end of the pipe */
sf_close(rfd);
rfd = sf_open(fifo2, O_RDONLY|DONT_BLOCK_PLEASE, 0);
if (rfd < 0) {
ERRNO_ERR1(LOG_ERR,"Could not open FIFO '%s' for reading.", fifo2);
exit(1);
}
got_some = 0; /* reset for next session */
}
else {
if(!wfd) {
/* Try to open the write pipe to to_erl. Now that we got some data
* from to_erl, to_erl should already be reading this pipe - open
* should succeed. But in case of error, we just ignore it.
*/
if ((wfd = sf_open(fifo1, O_WRONLY|DONT_BLOCK_PLEASE, 0)) < 0) {
status("Client expected on FIFO %s, but can't open (len=%d)\n",
fifo1, len);
sf_close(rfd);
rfd = sf_open(fifo2, O_RDONLY|DONT_BLOCK_PLEASE, 0);
if (rfd < 0) {
ERRNO_ERR1(LOG_ERR,"Could not open FIFO '%s' for reading.", fifo2);
exit(1);
}
wfd = 0;
}
else {
#ifdef DEBUG
status("run_erl: %s opened for writing\n", fifo1);
#endif
}
}
if (!got_some && wfd && buf[0] == '\014') {
char wbuf[30];
int wlen = sn_printf(wbuf,sizeof(wbuf),"[run_erl v%u-%u]\n",
RUN_ERL_HI_VER, RUN_ERL_LO_VER);
outbuf_append(wbuf,wlen);
}
got_some = 1;
/* Write the message */
#ifdef DEBUG
status("Pty master write; ");
#endif
len = extract_ctrl_seq(buf, len);
if(len==1 && buf[0] == '\003') {
kill(childpid,SIGINT);
}
else if (len>0 && write_all(mfd, buf, len) != len) {
ERRNO_ERR0(LOG_ERR,"Error in writing to terminal.");
sf_close(rfd);
if(wfd) sf_close(wfd);
sf_close(mfd);
exit(1);
}
}
#ifdef DEBUG
status("OK\n");
#endif
}
}
} /* pass_on() */
int erts_run_erl_log_open() {
LOG_NUM = find_next_log_num();
LFD = open_log(LOG_NUM, O_RDWR|O_APPEND|O_CREAT|O_SYNC);
return 0;
}
