diff options
Diffstat (limited to 'minilogd.c')
| -rw-r--r-- | minilogd.c | 184 |
1 files changed, 184 insertions, 0 deletions
diff --git a/minilogd.c b/minilogd.c new file mode 100644 index 0000000..76e4a9c --- /dev/null +++ b/minilogd.c @@ -0,0 +1,184 @@ + +/* minilogd.c + * + * A pale imitation of syslogd. Most notably, doesn't write anything + * anywhere except possibly back to syslogd. + * + */ + +#include <errno.h> +#include <fcntl.h> +#include <signal.h> +#include <stdio.h> +#include <stdlib.h> +#include <syslog.h> +#include <unistd.h> + +#include <sys/poll.h> +#include <sys/socket.h> +#include <sys/stat.h> +#include <sys/un.h> + +static int we_own_log=0; +static char **buffer=NULL; +static int buflines=0; + +int debug; + +int recvsock; + +void alarm_handler(int x) { + alarm(0); + close(recvsock); + recvsock = -1; +} + +void freeBuffer() { + struct sockaddr_un addr; + int sock; + int x=0,conn; + + bzero(&addr,sizeof(addr)); + addr.sun_family = AF_LOCAL; + strncpy(addr.sun_path,_PATH_LOG,sizeof(addr.sun_path)-1); + /* wait for klogd to hit syslog */ + sleep(2); + sock = socket(AF_LOCAL, SOCK_DGRAM,0); + conn=connect(sock,(struct sockaddr *) &addr,sizeof(addr)); + while (x<buflines) { + if (!conn) { + /*printf("to syslog: %s\n", buffer[x]);*/ + write(sock,buffer[x],strlen(buffer[x])+1); + } + free(buffer[x]); + x++; + } +} + +void cleanup(int exitcode) { + /* If we own the log, unlink it before trying to free our buffer. + * Otherwise, sending the buffer to /dev/log doesn't make much sense.... */ + if (we_own_log) { + perror("wol"); + unlink(_PATH_LOG); + } + /* Don't try to free buffer if we were called from a signal handler */ + if (exitcode<=0) { + if (buffer) freeBuffer(); + exit(exitcode); + } else + exit(exitcode+128); +} + +void runDaemon(int sock) { + struct sockaddr_un addr; + int x,len,addrlen,done=0; + char *message; + struct stat s1,s2; + struct pollfd pfds; + + daemon(0,-1); + /* try not to leave stale sockets lying around */ + /* Hopefully, we won't actually get any of these */ + signal(SIGHUP,cleanup); + signal(SIGINT,cleanup); + signal(SIGQUIT,cleanup); + signal(SIGILL,cleanup); + signal(SIGABRT,cleanup); + signal(SIGFPE,cleanup); + signal(SIGSEGV,cleanup); + signal(SIGPIPE,cleanup); + signal(SIGBUS,cleanup); + signal(SIGTERM,cleanup); + done = 0; + /* Get stat info on /dev/log so we can later check to make sure we + * still own it... */ + if (stat(_PATH_LOG,&s1) != 0) + memset(&s1, '\0', sizeof(struct stat)); + while (!done) { + pfds.fd = sock; + pfds.events = POLLIN|POLLPRI; + if ( ( (x=poll(&pfds,1,500))==-1) && errno !=EINTR) { + perror("poll"); + cleanup(-1); + } + if ( (x>0) && pfds.revents & (POLLIN | POLLPRI)) { + message = calloc(8192,sizeof(char)); + recvsock = accept(sock,(struct sockaddr *) &addr, &addrlen); + alarm(2); + signal(SIGALRM, alarm_handler); + len = read(recvsock,message,8192); + alarm(0); + close(recvsock); + if (len>0) { + /*printf("line recv'd: %s\n", message);*/ + if (buflines < 200000) { + if (buffer) + buffer = realloc(buffer,(buflines+1)*sizeof(char *)); + else + buffer = malloc(sizeof(char *)); + message[strlen(message)]='\n'; + buffer[buflines]=message; + buflines++; + } + } + else { + recvsock=-1; + } + } + if ( (x>0) && ( pfds.revents & (POLLHUP | POLLNVAL)) ) + done = 1; + /* Check to see if syslogd's yanked our socket out from under us */ + if ( (stat(_PATH_LOG,&s2)!=0) || + (s1.st_ino != s2.st_ino ) || (s1.st_ctime != s2.st_ctime) || + (s1.st_mtime != s2.st_mtime) ) { /*|| (s1.st_atime != s2.st_atime) ) {*/ + done = 1; + we_own_log = 0; + /*printf("someone stole our %s\n", _PATH_LOG); + printf("st_ino: %d %d\n", s1.st_ino, s2.st_ino); + printf("st_ctime: %d %d\n", s1.st_ctime, s2.st_ctime); + printf("st_atime: %d %d\n", s1.st_atime, s2.st_atime); + printf("st_mtime: %d %d\n", s1.st_mtime, s2.st_mtime);*/ + } + } + cleanup(0); +} + +int main(int argc, char **argv) { + struct sockaddr_un addr; + int sock; + int pid; + + /* option processing made simple... */ + if (argc>1) debug=1; + /* just in case */ + sock = open("/dev/null",O_RDWR); + dup2(sock,0); + dup2(sock,1); + dup2(sock,2); + + bzero(&addr, sizeof(addr)); + addr.sun_family = AF_LOCAL; + strncpy(addr.sun_path,_PATH_LOG,sizeof(addr.sun_path)-1); + sock = socket(AF_LOCAL, SOCK_STREAM,0); + unlink(_PATH_LOG); + /* Bind socket before forking, so we know if the server started */ + if (!bind(sock,(struct sockaddr *) &addr, sizeof(addr))) { + we_own_log = 1; + listen(sock,5); + if ((pid=fork())==-1) { + perror("fork"); + exit(3); + } + if (pid) { + exit(0); + } else { + /*printf("starting daemon...\n");*/ + runDaemon(sock); + /* shouldn't get back here... */ + exit(4); + } + } else { + exit(5); + } +} |