aboutsummaryrefslogtreecommitdiffstats
path: root/erts/etc/unix/run_erl.c
diff options
context:
space:
mode:
authorErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
committerErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
commit84adefa331c4159d432d22840663c38f155cd4c1 (patch)
treebff9a9c66adda4df2106dfd0e5c053ab182a12bd /erts/etc/unix/run_erl.c
downloadotp-84adefa331c4159d432d22840663c38f155cd4c1.tar.gz
otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.bz2
otp-84adefa331c4159d432d22840663c38f155cd4c1.zip
The R13B03 release.OTP_R13B03
Diffstat (limited to 'erts/etc/unix/run_erl.c')
-rw-r--r--erts/etc/unix/run_erl.c1298
1 files changed, 1298 insertions, 0 deletions
diff --git a/erts/etc/unix/run_erl.c b/erts/etc/unix/run_erl.c
new file mode 100644
index 0000000000..4bb148df98
--- /dev/null
+++ b/erts/etc/unix/run_erl.c
@@ -0,0 +1,1298 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 1996-2009. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * %CopyrightEnd%
+ */
+/*
+ * Module: run_erl.c
+ *
+ * This module implements a reader/writer process that opens two specified
+ * FIFOs, one for reading and one for writing; reads from the read FIFO
+ * and writes to stdout and the write FIFO.
+ *
+ ________ _________
+ | |--<-- pipe.r (fifo1) --<--| |
+ | to_erl | | run_erl | (parent)
+ |________|-->-- pipe.w (fifo2) -->--|_________|
+ ^ master pty
+ |
+ | slave pty
+ ____V____
+ | |
+ | "erl" | (child)
+ |_________|
+*/
+
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+#ifdef HAVE_WORKING_POSIX_OPENPT
+#define _XOPEN_SOURCE 600
+#endif
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/select.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <dirent.h>
+#include <termios.h>
+#include <time.h>
+#ifndef NO_SYSLOG
+# include <syslog.h>
+#endif
+#ifdef HAVE_PTY_H
+# include <pty.h>
+#endif
+#ifdef HAVE_UTMP_H
+# include <utmp.h>
+#endif
+#ifdef HAVE_UTIL_H
+# include <util.h>
+#endif
+#ifdef HAVE_SYS_IOCTL_H
+# include <sys/ioctl.h>
+#endif
+
+#include "run_erl.h"
+#include "safe_string.h" /* sn_printf, strn_cpy, strn_cat, etc */
+
+#ifdef O_NONBLOCK
+# define DONT_BLOCK_PLEASE O_NONBLOCK
+#else
+# define DONT_BLOCK_PLEASE O_NDELAY
+# ifndef EAGAIN
+# define EAGAIN -3898734
+# endif
+#endif
+
+#define noDEBUG
+
+#define DEFAULT_LOG_GENERATIONS 5
+#define LOG_MAX_GENERATIONS 1000 /* No more than 1000 log files */
+#define LOG_MIN_GENERATIONS 2 /* At least two to switch between */
+#define DEFAULT_LOG_MAXSIZE 100000
+#define LOG_MIN_MAXSIZE 1000 /* Smallast value for changing log file */
+#define LOG_STUBNAME "erlang.log."
+#define LOG_PERM 0664
+#define DEFAULT_LOG_ACTIVITY_MINUTES 5
+#define DEFAULT_LOG_ALIVE_MINUTES 15
+#define DEFAULT_LOG_ALIVE_FORMAT "%a %b %e %T %Z %Y"
+#define ALIVE_BUFFSIZ 256
+
+#define PERM 0600
+#define STATUSFILENAME "/run_erl.log"
+#define PIPE_STUBNAME "erlang.pipe"
+#define PIPE_STUBLEN strlen(PIPE_STUBNAME)
+
+#ifndef FILENAME_MAX
+#define FILENAME_MAX 250
+#endif
+
+#ifndef O_SYNC
+#define O_SYNC 0
+#define USE_FSYNC 1
+#endif
+
+#define MAX(x,y) ((x) > (y) ? (x) : (y))
+
+#define FILENAME_BUFSIZ FILENAME_MAX
+
+/* prototypes */
+static void usage(char *);
+static int create_fifo(char *name, int perm);
+static int open_pty_master(char **name);
+static int open_pty_slave(char *name);
+static void pass_on(pid_t);
+static void exec_shell(char **);
+static void status(const char *format,...);
+static void error_logf(int priority, int line, const char *format,...);
+static void catch_sigchild(int);
+static int next_log(int log_num);
+static int prev_log(int log_num);
+static int find_next_log_num(void);
+static int open_log(int log_num, int flags);
+static void write_to_log(int* lfd, int* log_num, char* buf, int len);
+static void daemon_init(void);
+static char *simple_basename(char *path);
+static void init_outbuf(void);
+static int outbuf_size(void);
+static void clear_outbuf(void);
+static char* outbuf_first(void);
+static void outbuf_delete(int bytes);
+static void outbuf_append(const char* bytes, int n);
+static int write_all(int fd, const char* buf, int len);
+static int extract_ctrl_seq(char* buf, int len);
+static void set_window_size(unsigned col, unsigned row);
+
+
+#ifdef DEBUG
+static void show_terminal_settings(struct termios *t);
+#endif
+
+/* static data */
+static char fifo1[FILENAME_BUFSIZ], fifo2[FILENAME_BUFSIZ];
+static char statusfile[FILENAME_BUFSIZ];
+static char log_dir[FILENAME_BUFSIZ];
+static char pipename[FILENAME_BUFSIZ];
+static FILE *stdstatus = NULL;
+static int log_generations = DEFAULT_LOG_GENERATIONS;
+static int log_maxsize = DEFAULT_LOG_MAXSIZE;
+static int log_alive_minutes = DEFAULT_LOG_ALIVE_MINUTES;
+static int log_activity_minutes = DEFAULT_LOG_ACTIVITY_MINUTES;
+static int log_alive_in_gmt = 0;
+static char log_alive_format[ALIVE_BUFFSIZ+1];
+static int run_daemon = 0;
+static char *program_name;
+static int mfd; /* master pty fd */
+static unsigned protocol_ver = RUN_ERL_LO_VER; /* assume lowest to begin with */
+
+/*
+ * Output buffer.
+ *
+ * outbuf_base <= outbuf_out <= outbuf_in <= outbuf_base+outbuf_total
+ */
+static char* outbuf_base;
+static int outbuf_total;
+static char* outbuf_out;
+static char* outbuf_in;
+
+#if defined(NO_SYSCONF) || !defined(_SC_OPEN_MAX)
+# if defined(OPEN_MAX)
+# define HIGHEST_FILENO() OPEN_MAX
+# else
+# define HIGHEST_FILENO() 64 /* arbitrary value */
+# endif
+#else
+# define HIGHEST_FILENO() sysconf(_SC_OPEN_MAX)
+#endif
+
+
+#ifdef NO_SYSLOG
+# define OPEN_SYSLOG() ((void) 0)
+#else
+# define OPEN_SYSLOG() openlog(simple_basename(program_name), \
+ LOG_PID|LOG_CONS|LOG_NOWAIT,LOG_USER)
+#endif
+
+#define ERROR0(Prio,Format) error_logf(Prio,__LINE__,Format"\n")
+#define ERROR1(Prio,Format,A1) error_logf(Prio,__LINE__,Format"\n",A1)
+#define ERROR2(Prio,Format,A1,A2) error_logf(Prio,__LINE__,Format"\n",A1,A2)
+
+#ifdef HAVE_STRERROR
+# define ADD_ERRNO(Format) "errno=%d '%s'\n"Format"\n",errno,strerror(errno)
+#else
+# define ADD_ERRNO(Format) "errno=%d\n"Format"\n",errno
+#endif
+#define ERRNO_ERR0(Prio,Format) error_logf(Prio,__LINE__,ADD_ERRNO(Format))
+#define ERRNO_ERR1(Prio,Format,A1) error_logf(Prio,__LINE__,ADD_ERRNO(Format),A1)
+
+
+int main(int argc, char **argv)
+{
+ int childpid;
+ int sfd;
+ int fd;
+ char *p, *ptyslave=NULL;
+ int i = 1;
+ int off_argv;
+
+ program_name = argv[0];
+
+ if(argc<4) {
+ usage(argv[0]);
+ exit(1);
+ }
+
+ init_outbuf();
+
+ if (!strcmp(argv[1],"-daemon")) {
+ daemon_init();
+ ++i;
+ }
+
+ off_argv = i;
+ strn_cpy(pipename, sizeof(pipename), argv[i++]);
+ strn_cpy(log_dir, sizeof(log_dir), argv[i]);
+ strn_cpy(statusfile, sizeof(statusfile), log_dir);
+ strn_cat(statusfile, sizeof(statusfile), STATUSFILENAME);
+
+#ifdef DEBUG
+ status("%s: pid is : %d\n", argv[0], getpid());
+#endif
+
+ /* Get values for LOG file handling from the environment */
+ if ((p = getenv("RUN_ERL_LOG_ALIVE_MINUTES"))) {
+ log_alive_minutes = atoi(p);
+ if (!log_alive_minutes) {
+ ERROR1(LOG_ERR,"Minimum value for RUN_ERL_LOG_ALIVE_MINUTES is 1 "
+ "(current value is %s)",p);
+ }
+ log_activity_minutes = log_alive_minutes / 3;
+ if (!log_activity_minutes) {
+ ++log_activity_minutes;
+ }
+ }
+ if ((p = getenv("RUN_ERL_LOG_ACTIVITY_MINUTES"))) {
+ log_activity_minutes = atoi(p);
+ if (!log_activity_minutes) {
+ ERROR1(LOG_ERR,"Minimum value for RUN_ERL_LOG_ACTIVITY_MINUTES is 1 "
+ "(current value is %s)",p);
+ }
+ }
+ if ((p = getenv("RUN_ERL_LOG_ALIVE_FORMAT"))) {
+ if (strlen(p) > ALIVE_BUFFSIZ) {
+ ERROR1(LOG_ERR, "RUN_ERL_LOG_ALIVE_FORMAT can contain a maximum of "
+ "%d characters", ALIVE_BUFFSIZ);
+ }
+ strn_cpy(log_alive_format, sizeof(log_alive_format), p);
+ } else {
+ strn_cpy(log_alive_format, sizeof(log_alive_format), DEFAULT_LOG_ALIVE_FORMAT);
+ }
+ if ((p = getenv("RUN_ERL_LOG_ALIVE_IN_UTC")) && strcmp(p,"0")) {
+ ++log_alive_in_gmt;
+ }
+ if ((p = getenv("RUN_ERL_LOG_GENERATIONS"))) {
+ log_generations = atoi(p);
+ if (log_generations < LOG_MIN_GENERATIONS)
+ ERROR1(LOG_ERR,"Minimum RUN_ERL_LOG_GENERATIONS is %d", LOG_MIN_GENERATIONS);
+ if (log_generations > LOG_MAX_GENERATIONS)
+ ERROR1(LOG_ERR,"Maximum RUN_ERL_LOG_GENERATIONS is %d", LOG_MAX_GENERATIONS);
+ }
+
+ if ((p = getenv("RUN_ERL_LOG_MAXSIZE"))) {
+ log_maxsize = atoi(p);
+ if (log_maxsize < LOG_MIN_MAXSIZE)
+ ERROR1(LOG_ERR,"Minimum RUN_ERL_LOG_MAXSIZE is %d", LOG_MIN_MAXSIZE);
+ }
+
+ /*
+ * Create FIFOs and open them
+ */
+
+ if(*pipename && pipename[strlen(pipename)-1] == '/') {
+ /* The user wishes us to find a unique pipe name in the specified */
+ /* directory */
+ int highest_pipe_num = 0;
+ DIR *dirp;
+ struct dirent *direntp;
+
+ dirp = opendir(pipename);
+ if(!dirp) {
+ ERRNO_ERR1(LOG_ERR,"Can't access pipe directory '%s'.", pipename);
+ exit(1);
+ }
+
+ /* Check the directory for existing pipes */
+
+ while((direntp=readdir(dirp)) != NULL) {
+ if(strncmp(direntp->d_name,PIPE_STUBNAME,PIPE_STUBLEN)==0) {
+ int num = atoi(direntp->d_name+PIPE_STUBLEN+1);
+ if(num > highest_pipe_num)
+ highest_pipe_num = num;
+ }
+ }
+ closedir(dirp);
+ strn_catf(pipename, sizeof(pipename), "%s.%d",
+ PIPE_STUBNAME, highest_pipe_num+1);
+ } /* if */
+
+ /* write FIFO - is read FIFO for `to_erl' program */
+ strn_cpy(fifo1, sizeof(fifo1), pipename);
+ strn_cat(fifo1, sizeof(fifo1), ".r");
+ if (create_fifo(fifo1, PERM) < 0) {
+ ERRNO_ERR1(LOG_ERR,"Cannot create FIFO %s for writing.", fifo1);
+ exit(1);
+ }
+
+ /* read FIFO - is write FIFO for `to_erl' program */
+ strn_cpy(fifo2, sizeof(fifo2), pipename);
+ strn_cat(fifo2, sizeof(fifo2), ".w");
+
+ /* Check that nobody is running run_erl already */
+ if ((fd = open (fifo2, O_WRONLY|DONT_BLOCK_PLEASE, 0)) >= 0) {
+ /* Open as client succeeded -- run_erl is already running! */
+ fprintf(stderr, "Erlang already running on pipe %s.\n", pipename);
+ close(fd);
+ exit(1);
+ }
+ if (create_fifo(fifo2, PERM) < 0) {
+ ERRNO_ERR1(LOG_ERR,"Cannot create FIFO %s for reading.", fifo2);
+ exit(1);
+ }
+
+ /*
+ * Open master pseudo-terminal
+ */
+
+ if ((mfd = open_pty_master(&ptyslave)) < 0) {
+ ERRNO_ERR0(LOG_ERR,"Could not open pty master");
+ exit(1);
+ }
+
+ /*
+ * Now create a child process
+ */
+
+ if ((childpid = fork()) < 0) {
+ ERRNO_ERR0(LOG_ERR,"Cannot fork");
+ exit(1);
+ }
+ if (childpid == 0) {
+ /* Child */
+ close(mfd);
+ /* disassociate from control terminal */
+#ifdef USE_SETPGRP_NOARGS /* SysV */
+ setpgrp();
+#elif defined(USE_SETPGRP) /* BSD */
+ setpgrp(0,getpid());
+#else /* POSIX */
+ setsid();
+#endif
+ /* Open the slave pty */
+ if ((sfd = open_pty_slave(ptyslave)) < 0) {
+ ERRNO_ERR1(LOG_ERR,"Could not open pty slave '%s'", ptyslave);
+ exit(1);
+ }
+ /* But sfd may be one of the stdio fd's now, and we should be unmodern and not use dup2... */
+ /* easiest to dup it up... */
+ while (sfd < 3) {
+ sfd = dup(sfd);
+ }
+
+#ifndef NO_SYSLOG
+ /* Before fiddling with file descriptors we make sure syslog is turned off
+ or "closed". In the single case where we might want it again,
+ we will open it again instead. Would not want syslog to
+ go to some other fd... */
+ if (run_daemon) {
+ closelog();
+ }
+#endif
+
+ /* Close stdio */
+ close(0);
+ close(1);
+ close(2);
+
+ if (dup(sfd) != 0 || dup(sfd) != 1 || dup(sfd) != 2) {
+ status("Cannot dup\n");
+ }
+ close(sfd);
+ exec_shell(argv+off_argv); /* exec_shell expects argv[2] to be */
+ /* the command name, so we have to */
+ /* adjust. */
+ } else {
+ /* Parent */
+ /* Ignore the SIGPIPE signal, write() will return errno=EPIPE */
+ struct sigaction sig_act;
+ sigemptyset(&sig_act.sa_mask);
+ sig_act.sa_flags = 0;
+ sig_act.sa_handler = SIG_IGN;
+ sigaction(SIGPIPE, &sig_act, (struct sigaction *)NULL);
+
+ sigemptyset(&sig_act.sa_mask);
+ sig_act.sa_flags = SA_NOCLDSTOP;
+ sig_act.sa_handler = catch_sigchild;
+ sigaction(SIGCHLD, &sig_act, (struct sigaction *)NULL);
+
+ /*
+ * read and write: enter the workloop
+ */
+
+ pass_on(childpid);
+ }
+ return 0;
+} /* main() */
+
+/* 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 = 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 = 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();
+ 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 = read(mfd, buf, BUFSIZ)) <= 0) {
+ close(rfd);
+ if(wfd) close(wfd);
+ 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 = read(rfd, buf, BUFSIZ)) < 0) {
+ close(rfd);
+ if(wfd) close(wfd);
+ 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 */
+ close(rfd);
+ rfd = 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 = open(fifo1, O_WRONLY|DONT_BLOCK_PLEASE, 0)) < 0) {
+ status("Client expected on FIFO %s, but can't open (len=%d)\n",
+ fifo1, len);
+ close(rfd);
+ rfd = 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] == '\022') {
+ 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.");
+ close(rfd);
+ if(wfd) close(wfd);
+ close(mfd);
+ exit(1);
+ }
+ }
+#ifdef DEBUG
+ status("OK\n");
+#endif
+ }
+ }
+} /* pass_on() */
+
+static void catch_sigchild(int sig)
+{
+}
+
+/*
+ * next_log:
+ * Returns the index number that follows the given index number.
+ * (Wrapping after log_generations)
+ */
+static int next_log(int log_num) {
+ return log_num>=log_generations?1:log_num+1;
+}
+
+/*
+ * prev_log:
+ * Returns the index number that precedes the given index number.
+ * (Wrapping after log_generations)
+ */
+static int prev_log(int log_num) {
+ return log_num<=1?log_generations:log_num-1;
+}
+
+/*
+ * find_next_log_num()
+ * Searches through the log directory to check which logs that already
+ * exist. It finds the "hole" in the sequence, and returns the index
+ * number for the last log in the log sequence. If there is no hole, index
+ * 1 is returned.
+ */
+static int find_next_log_num(void) {
+ int i, next_gen, log_gen;
+ DIR *dirp;
+ struct dirent *direntp;
+ int log_exists[LOG_MAX_GENERATIONS+1];
+ int stub_len = strlen(LOG_STUBNAME);
+
+ /* Initialize exiting log table */
+
+ for(i=log_generations; i>=0; i--)
+ log_exists[i] = 0;
+ dirp = opendir(log_dir);
+ if(!dirp) {
+ ERRNO_ERR1(LOG_ERR,"Can't access log directory '%s'", log_dir);
+ exit(1);
+ }
+
+ /* Check the directory for existing logs */
+
+ while((direntp=readdir(dirp)) != NULL) {
+ if(strncmp(direntp->d_name,LOG_STUBNAME,stub_len)==0) {
+ int num = atoi(direntp->d_name+stub_len);
+ if(num < 1 || num > log_generations)
+ continue;
+ log_exists[num] = 1;
+ }
+ }
+ closedir(dirp);
+
+ /* Find out the next available log file number */
+
+ next_gen = 0;
+ for(i=log_generations; i>=0; i--) {
+ if(log_exists[i])
+ if(next_gen)
+ break;
+ else
+ ;
+ else
+ next_gen = i;
+ }
+
+ /* Find out the current log file number */
+
+ if(next_gen)
+ log_gen = prev_log(next_gen);
+ else
+ log_gen = 1;
+
+ return log_gen;
+} /* find_next_log_num() */
+
+/* open_log()
+ * Opens a log file (with given index) for writing. Writing may be
+ * at the end or a trucnating write, according to flags.
+ * A LOGGING STARTED and time stamp message is inserted into the log file
+ */
+static int open_log(int log_num, int flags)
+{
+ char buf[FILENAME_MAX];
+ time_t now;
+ struct tm *tmptr;
+ char log_buffer[ALIVE_BUFFSIZ+1];
+ int lfd;
+
+ /* Remove the next log (to keep a "hole" in the log sequence) */
+ sn_printf(buf, sizeof(buf), "%s/%s%d",
+ log_dir, LOG_STUBNAME, next_log(log_num));
+ unlink(buf);
+
+ /* Create or continue on the current log file */
+ sn_printf(buf, sizeof(buf), "%s/%s%d", log_dir, LOG_STUBNAME, log_num);
+ if((lfd = open(buf, flags, LOG_PERM))<0){
+ ERRNO_ERR1(LOG_ERR,"Can't open log file '%s'.", buf);
+ exit(1);
+ }
+
+ /* Write a LOGGING STARTED and time stamp into the log file */
+ time(&now);
+ if (log_alive_in_gmt) {
+ tmptr = gmtime(&now);
+ } else {
+ tmptr = localtime(&now);
+ }
+ if (!strftime(log_buffer, ALIVE_BUFFSIZ, log_alive_format,
+ tmptr)) {
+ strn_cpy(log_buffer, sizeof(log_buffer),
+ "(could not format time in 256 positions "
+ "with current format string.)");
+ }
+ log_buffer[ALIVE_BUFFSIZ] = '\0';
+
+ sn_printf(buf, sizeof(buf), "\n=====\n===== LOGGING STARTED %s\n=====\n",
+ log_buffer);
+ if (write_all(lfd, buf, strlen(buf)) < 0)
+ status("Error in writing to log.\n");
+
+#if USE_FSYNC
+ fsync(lfd);
+#endif
+
+ return lfd;
+}
+
+/* write_to_log()
+ * Writes a message to a log file. If the current log file is full,
+ * a new log file is opened.
+ */
+static void write_to_log(int* lfd, int* log_num, char* buf, int len)
+{
+ int size;
+
+ /* Decide if new logfile needed, and open if so */
+
+ size = lseek(*lfd,0,SEEK_END);
+ if(size+len > log_maxsize) {
+ close(*lfd);
+ *log_num = next_log(*log_num);
+ *lfd = open_log(*log_num, O_RDWR|O_CREAT|O_TRUNC|O_SYNC);
+ }
+
+ /* Write to log file */
+
+ if (write_all(*lfd, buf, len) < 0) {
+ status("Error in writing to log.\n");
+ }
+
+#if USE_FSYNC
+ fsync(*lfd);
+#endif
+}
+
+/* create_fifo()
+ * Creates a new fifo with the given name and permission.
+ */
+static int create_fifo(char *name, int perm)
+{
+ if ((mkfifo(name, perm) < 0) && (errno != EEXIST))
+ return -1;
+ return 0;
+}
+
+
+/* open_pty_master()
+ * Find a master device, open and return fd and slave device name.
+ */
+
+static int open_pty_master(char **ptyslave)
+{
+ int mfd;
+
+/* Use the posix_openpt if working, as this guarantees creation of the
+ slave device properly. */
+#ifdef HAVE_WORKING_POSIX_OPENPT
+ if ((mfd = posix_openpt(O_RDWR)) >= 0) {
+ if ((*ptyslave = ptsname(mfd)) != NULL &&
+ grantpt(mfd) == 0 &&
+ unlockpt(mfd) == 0) {
+
+ return mfd;
+ }
+ close(mfd);
+ }
+ /* fallback to openpty if it exist */
+#endif
+
+#ifdef HAVE_OPENPTY
+# ifdef PATH_MAX
+# define SLAVE_SIZE PATH_MAX
+# else
+# define SLAVE_SIZE 1024
+# endif
+ {
+ static char slave[SLAVE_SIZE];
+ int sfd;
+# undef SLAVE_SIZE
+
+ if (openpty(&mfd, &sfd, slave, NULL, NULL) == 0) {
+ close(sfd);
+ *ptyslave = slave;
+ return mfd;
+ }
+ }
+
+#elif !defined(HAVE_WORKING_POSIX_OPENPT)
+ /*
+ * The traditional way to find ptys. We only try it if neither
+ * posix_openpt or openpty() are available.
+ */
+ char *major, *minor;
+
+ static char majorchars[] = "pqrstuvwxyzabcdePQRSTUVWXYZABCDE";
+ static char minorchars[] = "0123456789abcdefghijklmnopqrstuv"
+ "wxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_+";
+
+ /* In the old time the names where /dex/ptyXY where */
+ /* X is in "pqrs" and Y in "0123456789abcdef" but FreeBSD */
+ /* and some Linux version has extended this. */
+
+ /* This code could probebly be improved alot. For example look at */
+ /* http://www.xcf.berkeley.edu/~ali/K0D/UNIX/PTY/code/pty.c.html */
+ /* http://www.xcf.berkeley.edu/~ali/K0D/UNIX/PTY/code/upty.h.html */
+
+ {
+ /* New style devpts or devfs /dev/pty/{m,s}{0,1....} */
+
+ static char ptyname[] = "/dev/pty/mX";
+
+ for (minor = minorchars; *minor; minor++) {
+ ptyname[10] = *minor;
+ if ((mfd = open(ptyname, O_RDWR, 0)) >= 0) {
+ ptyname[9] = 's';
+ *ptyslave = ptyname;
+ return mfd;
+ }
+ }
+ }
+
+ {
+ /* Unix98 style /dev/ptym/ptyXY and /dev/pty/ttyXY */
+
+ static char ptyname[] = "/dev/ptym/ptyXY";
+ static char ttyname[] = "/dev/pty/ttyXY";
+
+ for (major = majorchars; *major; major++) {
+ ptyname[13] = *major;
+ for (minor = minorchars; *minor; minor++) {
+ ptyname[14] = *minor;
+ if ((mfd = open(ptyname, O_RDWR, 0)) >= 0) {
+ ttyname[12] = *major;
+ ttyname[13] = *minor;
+ *ptyslave = ttyname;
+ return mfd;
+ }
+ }
+ }
+ }
+
+ {
+ /* Old style /dev/ptyXY */
+
+ static char ptyname[] = "/dev/ptyXY";
+
+ for (major = majorchars; *major; major++) {
+ ptyname[8] = *major;
+ for (minor = minorchars; *minor; minor++) {
+ ptyname[9] = *minor;
+ if ((mfd = open(ptyname, O_RDWR, 0)) >= 0) {
+ ptyname[5] = 't';
+ *ptyslave = ptyname;
+ return mfd;
+ }
+ }
+ }
+ }
+#endif /* !HAVE_OPENPTY */
+ return -1;
+}
+
+static int open_pty_slave(char *name)
+{
+ int sfd;
+#ifdef DEBUG
+ struct termios tty_rmode;
+#endif
+
+ if ((sfd = open(name, O_RDWR, 0)) < 0) {
+ return -1;
+ }
+
+#ifdef DEBUG
+ if (tcgetattr(sfd, &tty_rmode) , 0) {
+ fprintf(stderr, "Cannot get terminals current mode\n");
+ exit(-1);
+ }
+ show_terminal_settings(&tty_rmode);
+#endif
+
+ return sfd;
+}
+
+/* exec_shell()
+ * Executes the named command (in argv format) in a /bin/sh. IO redirection
+ * should already have been taken care of, and this process should be the
+ * child of a fork.
+ */
+static void exec_shell(char **argv)
+{
+ char *sh, **vp;
+ int i;
+
+ sh = "/bin/sh";
+ if ((argv[0] = strrchr(sh, '/')) != NULL)
+ argv[0]++;
+ else
+ argv[0] = sh;
+ argv[1] = "-c";
+ status("Args before exec of shell:\n");
+ for (vp = argv, i = 0; *vp; vp++, i++)
+ status("argv[%d] = %s\n", i, *vp);
+ if (stdstatus) {
+ fclose(stdstatus);
+ }
+ execv(sh, argv);
+ if (run_daemon) {
+ OPEN_SYSLOG();
+ }
+ ERRNO_ERR0(LOG_ERR,"Could not execv");
+}
+
+/* status()
+ * Prints the arguments to a status file
+ * Works like printf (see vfrpintf)
+ */
+static void status(const char *format,...)
+{
+ va_list args;
+ time_t now;
+
+ if (stdstatus == NULL)
+ stdstatus = fopen(statusfile, "w");
+ if (stdstatus == NULL)
+ return;
+ now = time(NULL);
+ fprintf(stdstatus, "run_erl [%d] %s", (int)getpid(), ctime(&now));
+ va_start(args, format);
+ vfprintf(stdstatus, format, args);
+ va_end(args);
+ fflush(stdstatus);
+}
+
+static void daemon_init(void)
+ /* As R Stevens wants it, to a certain extent anyway... */
+{
+ pid_t pid;
+ int i, maxfd = HIGHEST_FILENO();
+
+ if ((pid = fork()) != 0)
+ exit(0);
+#if defined(USE_SETPGRP_NOARGS)
+ setpgrp();
+#elif defined(USE_SETPGRP)
+ setpgrp(0,getpid());
+#else
+ setsid(); /* Seems to be the case on all current platforms */
+#endif
+ signal(SIGHUP, SIG_IGN);
+ if ((pid = fork()) != 0)
+ exit(0);
+
+ /* Should change working directory to "/" and change umask now, but that
+ would be backward incompatible */
+
+ for (i = 0; i < maxfd; ++i ) {
+ close(i);
+ }
+
+ OPEN_SYSLOG();
+ run_daemon = 1;
+}
+
+/* error_logf()
+ * Prints the arguments to stderr or syslog
+ * Works like printf (see vfprintf)
+ */
+static void error_logf(int priority, int line, const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+
+#ifndef NO_SYSLOG
+ if (run_daemon) {
+ vsyslog(priority,format,args);
+ }
+ else
+#endif
+ {
+ time_t now = time(NULL);
+ fprintf(stderr, "run_erl:%d [%d] %s", line, (int)getpid(), ctime(&now));
+ vfprintf(stderr, format, args);
+ }
+ va_end(args);
+}
+
+static void usage(char *pname)
+{
+ fprintf(stderr, "Usage: %s (pipe_name|pipe_dir/) log_dir \"command [parameters ...]\"\n", pname);
+ fprintf(stderr, "\nYou may also set the environment variables RUN_ERL_LOG_GENERATIONS\n");
+ fprintf(stderr, "and RUN_ERL_LOG_MAXSIZE to the number of log files to use and the\n");
+ fprintf(stderr, "size of the log file when to switch to the next log file\n");
+}
+
+/* Instead of making sure basename exists, we do our own */
+static char *simple_basename(char *path)
+{
+ char *ptr;
+ for (ptr = path; *ptr != '\0'; ++ptr) {
+ if (*ptr == '/') {
+ path = ptr + 1;
+ }
+ }
+ return path;
+}
+
+static void init_outbuf(void)
+{
+ outbuf_total = 1;
+ outbuf_base = malloc(BUFSIZ);
+ clear_outbuf();
+}
+
+static void clear_outbuf(void)
+{
+ outbuf_in = outbuf_out = outbuf_base;
+}
+
+static int outbuf_size(void)
+{
+ return outbuf_in - outbuf_out;
+}
+
+static char* outbuf_first(void)
+{
+ return outbuf_out;
+}
+
+static void outbuf_delete(int bytes)
+{
+ outbuf_out += bytes;
+ if (outbuf_out >= outbuf_in) {
+ outbuf_in = outbuf_out = outbuf_base;
+ }
+}
+
+static void outbuf_append(const char* buf, int n)
+{
+ if (outbuf_base+outbuf_total < outbuf_in+n) {
+ /*
+ * The new data does not fit at the end of the buffer.
+ * Slide down the data to the beginning of the buffer.
+ */
+ if (outbuf_out > outbuf_base) {
+ int size = outbuf_in - outbuf_out;
+ char* p;
+
+ outbuf_in -= outbuf_out - outbuf_base;
+ p = outbuf_base;
+ while (size-- > 0) {
+ *p++ = *outbuf_out++;
+ }
+ outbuf_out = outbuf_base;
+ }
+
+ /*
+ * Allocate a larger buffer if we still cannot fit the data.
+ */
+ if (outbuf_base+outbuf_total < outbuf_in+n) {
+ int size = outbuf_in - outbuf_out;
+ outbuf_total = size+n;
+ outbuf_base = realloc(outbuf_base, outbuf_total);
+ outbuf_out = outbuf_base;
+ outbuf_in = outbuf_base + size;
+ }
+ }
+
+ /*
+ * Copy data to the end of the buffer.
+ */
+ memcpy(outbuf_in, buf, n);
+ outbuf_in += n;
+}
+
+/* Call write() until entire buffer has been written or error.
+ * Return len or -1.
+ */
+static int write_all(int fd, const char* buf, int len)
+{
+ int left = len;
+ int written;
+ for (;;) {
+ written = write(fd,buf,left);
+ if (written == left) {
+ return len;
+ }
+ if (written < 0) {
+ return -1;
+ }
+ left -= written;
+ buf += written;
+ }
+}
+
+/* Extract any control sequences that are ment only for run_erl
+ * and should not be forwarded to the pty.
+ */
+static int extract_ctrl_seq(char* buf, int len)
+{
+ static const char prefix[] = "\033_";
+ static const char suffix[] = "\033\\";
+ char* bufend = buf + len;
+ char* start = buf;
+ char* command;
+ char* end;
+
+ for (;;) {
+ start = find_str(start, bufend-start, prefix);
+ if (!start) break;
+
+ command = start + strlen(prefix);
+ end = find_str(command, bufend-command, suffix);
+ if (end) {
+ unsigned col, row;
+ if (sscanf(command,"version=%u", &protocol_ver)==1) {
+ /*fprintf(stderr,"to_erl v%u\n", protocol_ver);*/
+ }
+ else if (sscanf(command,"winsize=%u,%u", &col, &row)==2) {
+ set_window_size(col,row);
+ }
+ else {
+ ERROR2(LOG_ERR, "Ignoring unknown ctrl command '%.*s'\n",
+ (int)(end-command), command);
+ }
+
+ /* Remove ctrl sequence from buf */
+ end += strlen(suffix);
+ memmove(start, end, bufend-end);
+ bufend -= end - start;
+ }
+ else {
+ ERROR2(LOG_ERR, "Missing suffix in ctrl sequence '%.*s'\n",
+ (int)(bufend-start), start);
+ break;
+ }
+ }
+ return bufend - buf;
+}
+
+static void set_window_size(unsigned col, unsigned row)
+{
+#ifdef TIOCSWINSZ
+ struct winsize ws;
+ ws.ws_col = col;
+ ws.ws_row = row;
+ if (ioctl(mfd, TIOCSWINSZ, &ws) < 0) {
+ ERRNO_ERR0(LOG_ERR,"Failed to set window size");
+ }
+#endif
+}
+
+
+#ifdef DEBUG
+
+#define S(x) ((x) > 0 ? 1 : 0)
+
+static void show_terminal_settings(struct termios *t)
+{
+ printf("c_iflag:\n");
+ printf("Signal interrupt on break: BRKINT %d\n", S(t->c_iflag & BRKINT));
+ printf("Map CR to NL on input: ICRNL %d\n", S(t->c_iflag & ICRNL));
+ printf("Ignore break condition: IGNBRK %d\n", S(t->c_iflag & IGNBRK));
+ printf("Ignore CR: IGNCR %d\n", S(t->c_iflag & IGNCR));
+ printf("Ignore char with par. err's: IGNPAR %d\n", S(t->c_iflag & IGNPAR));
+ printf("Map NL to CR on input: INLCR %d\n", S(t->c_iflag & INLCR));
+ printf("Enable input parity check: INPCK %d\n", S(t->c_iflag & INPCK));
+ printf("Strip character ISTRIP %d\n", S(t->c_iflag & ISTRIP));
+ printf("Enable start/stop input ctrl IXOFF %d\n", S(t->c_iflag & IXOFF));
+ printf("ditto output ctrl IXON %d\n", S(t->c_iflag & IXON));
+ printf("Mark parity errors PARMRK %d\n", S(t->c_iflag & PARMRK));
+ printf("\n");
+ printf("c_oflag:\n");
+ printf("Perform output processing OPOST %d\n", S(t->c_oflag & OPOST));
+ printf("\n");
+ printf("c_cflag:\n");
+ printf("Ignore modem status lines CLOCAL %d\n", S(t->c_cflag & CLOCAL));
+ printf("\n");
+ printf("c_local:\n");
+ printf("Enable echo ECHO %d\n", S(t->c_lflag & ECHO));
+ printf("\n");
+ printf("c_cc:\n");
+ printf("c_cc[VEOF] %d\n", t->c_cc[VEOF]);
+}
+
+#endif /* DEBUG */
+
+