Apple-2gs-SW
/
gno
mirror of https://github.com/GnoConsortium/gno.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
gno/usr.sbin/syslogd/syslogd2.c

604 lines
14 KiB
C
Raw Blame History

/*
* This implementation of syslogd was written by Devin Reade for GNO v2.0.6.
* It was written because Phil Vandry's original version of syslogd didn't
* have sufficient bits for the facility/priority values, and at the time
* his sources weren't available for modification.
*
* $Id: syslogd2.c,v 1.2 2012/08/26 02:55:00 gdr Exp $
*/
/*
* To Do:
* - get all our configuration from the syslog.conf file, and use that
* information in logMessage()
* - background ourselves
* - eliminate the command line args, except for "-f conf_file"
* - internal error messages should go through a logInternal
* routine so that they can potentially go to a file as well
* as (instead of?) the console
* - the main loop should be rewritten so that it immediately copies
* the data and releases the caller rather than waiting until it
* has parsed the buffer.
* - eliminate various pieces of dead code, clean up comments
* - ensure all routines are properly documented
* - should writeConsole be exported to libc?
* - in order to do 'mark' entries, we could set up a signal handler
* for SIGALRM. We'll either need a semaphore or a signal mask
* set up so that we can't get interrupted by SIGHUP or SIGTERM
* while we're in the SIGALRM handler.
* - should logInternal be using the internal "none" priority?
* - logMessage should be modified to ensure that there is a trailing
* newline. Internal messages (at least) via logInternal are currently
* missing newlines.
*/
/*
* How many processes can send to us before they block? We don't need many
* since syslog(3), vsyslog(3), syslogmt(3), and vsyslogmt(3) won't return
* until we handle the request, anyway.
*
* Since sendPort() in the syslog(3) implementation is currently doing a
* busy wait while waiting for syslogd to release it's buffer, we set NPORTS
* to 1 so that any additional senders get blocked by the kernel instead of
* using up clock cycles.
*/
#define NPORTS 1
/*
* Define DEBUG to get syslogd to exit after a NLOOPS loops. Why do we
* need this? Because there is a bug in the v2.0.6 kernel which kills our
* shell if we send a SIGTERM to a child process. Blech. Limiting the
* number of loops lets us proceed with debugging without always having to
* log in again. See PR#53 in the GNO bug report system.
*
#if 0
#define DEBUG
#define NLOOPS 5
#endif
/* We need this for internal structs in <sys/syslog.h> */
#define __SYSLOG_INTERNALS
#include <sys/types.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <sys/ports.h>
#include <sys/syslog.h>
#include <time.h>
#include <errno.h>
#include <gno/gno.h>
#include <signal.h>
#include <paths.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <fcntl.h>
#include <memory.h>
#include <misctool.h>
#ifdef __STACK_CHECK__
#include <err.h>
#endif
#include <assert.h>
#include <ctype.h> /* debugging only */
#include "syslogd.h"
#ifndef EOF
#define EOF (-1)
#endif
#define MIN(a,b) ((a) < (b) ? (a) :(b))
#if 0
static void die (const char *message);
#endif
static int logMessage (int facpri, char *msg, int len);
static int writeConsole (const char *buf, size_t size);
#if 0
static void handle_HUP (int sig, int code);
#endif
static void handle_TERM (int sig, int code);
int Port = -1;
char MessageBuffer[_SYSLOG_BUFFERLEN];
int MessageBufferLen = 0; /* number of used chars in MessageBuffer */
int bytesToCopy;
int FacPri; /* facility/priorty */
time_t Now;
char * LogFile = NULL; /* temporary kludge */
int LogConsole = 0; /* temporary kludge */
static void handleVersionZero (SyslogDataBuffer0_t *dataptr0);
int
main(int argc, char **argv) {
int fd, ch, isVersionZero;
union {
SyslogDataBuffer0_t *v0;
SyslogDataBuffer_t *vN;
} datap;
char *p, *q;
Handle datahandle;
Word oldID, myID;
#ifdef DEBUG
int loopcount = 0;
#endif
#ifdef __STACK_CHECK__
/*
* Don't use the __REPORT_STACK() macro here; we don't want
* to have to call atexit() since we may be in a signal handler
* when we have to die.
*/
_beginStackCheck();
#endif
/* We'll be needing our mem mgr ID later ... */
myID = _getUserID();
while ((ch = getopt(argc, argv, "cF:")) != EOF) {
switch(ch) {
case 'c':
LogConsole = 1;
break;
case 'F':
LogFile = optarg;
break;
default:
logInternal("usage: syslogd [-c] [-F logfile]");
exit(1);
}
}
#if 0
{
char *myname;
myname = __prognameGS();
writeConsole(argv[0], strlen(argv[0]));
writeConsole("/", 1);
writeConsole(myname, strlen(myname));
}
#endif
#if 0
signal(SIGHUP, handle_HUP);
#endif
signal(SIGTERM, handle_TERM);
/* detach from controlling terminal */
if ((fd = open(_PATH_TTY, O_RDWR)) < 0) {
logInternal("couldn't open controlling terminal: %s",
strerror(errno));
exit(1);
}
#if 0
if (tcnewpgrp(fd) < 0) {
logInternal("tcnewpgrp failed: %s", strerror(errno));
exit(1);
}
#endif
if (ioctl(fd, TIOCNOTTY, 0) < 0) {
logInternal("ioctl failed: %s", strerror(errno));
exit(1);
}
close(fd);
/* create and bind a port on which programs can contact us */
if ((Port = pcreate(NPORTS)) == -1) {
/*
* Does this actually ever happen? The ports(2) man page
* does not document an error condition for pcreate(2).
*/
logInternal("couldn't create port: %s", strerror(errno));
exit(1);
}
logInternal("DEBUG: got port %d", Port);
#undef __SYSLOG_PORT_NAME
#define __SYSLOG_PORT_NAME "syslogd_test"
if (pbind (Port, __SYSLOG_PORT_NAME) == -1) {
#if 0
logInternal("DEBUG: Bound port first time");
/* KLUDGE KLUDGE KLUDGE
* Kill off the old v1 syslogd
*/
kill(3, SIGTERM);
sleep(1);
if (pbind(Port, __SYSLOG_PORT_NAME) == -1) {
#endif
logInternal("couldn't bind port: %s", strerror(errno));
exit(1);
#if 0
}
#endif
}
logInternal("DEBUG: bound to port");
/* now loop forever waiting for messages */
for (;;) {
#ifdef DEBUG
loopcount++;
if (loopcount > NLOOPS) {
# ifdef __STACK_CHECK__
logInternal("%d bytes used", _endStackCheck());
# endif
logInternal("Done debugging loops. Exiting.");
exit(0);
}
#endif
logInternal("Entering loop");
/* block until a message comes in */
datahandle = (Handle) preceive(Port);
/* paranoia */
if (datahandle == NULL) {
logInternal("Received NULL pointer. Discarded.");
continue;
}
CheckHandle(datahandle);
if (_toolErr) {
if (_toolErr == handleErr) {
logInternal("invalid handle 0x%lx: message dropped",
(unsigned long) datahandle);
} else {
logInternal("CheckHandle on 0x%lx failed with code %d",
(unsigned long) datahandle,
_toolErr);
}
continue;
}
/* Change the memory block to be owned by our ID */
oldID = SetHandleID(myID, datahandle);
/* lock the handle */
HLock(datahandle);
if (_toolErr) {
logInternal("HLock on 0x%lx failed with code %d",
(unsigned long) datahandle, _toolErr);
}
/* , and
* free up the old ID
*/
{
int *iptr, j;
char *cptr, c;
iptr = (int *) *datahandle;
cptr = (char *) &iptr[5];
logInternal("buffer: %d %d %d %d %d:\r",
iptr[0], iptr[1], iptr[2], iptr[3], iptr[4]);
for (j=0; j<iptr[4]; j++) {
c = cptr[j];
logInternal("GSString[%d] = 0x%x '%c'",
j, (int) c, isprint(c) ? c : '?');
}
continue;
}
#ifdef BORK
/* dereference the handle */
datap.vN = (SyslogDataBuffer_t *) *datahandle;
/* determine if it's an old version zero message */
isVersionZero = (datap.v0->sdb0_version == 0);
if (isVersionZero) {
handleVersionZero(datap.v0);
HUnlock(datahandle); /* ignore errors */
continue;
} else {
DeleteID (oldID);
logInternal("not version zero");
HUnlock(datahandle); /* ignore errors */
continue;
}
if (isVersionZero) {
FacPri = datap.v0->sdb0_prio;
} else {
/* verify that this isn't a garbage pointer */
if (datap.vN->sdb_magic != _SYSLOG_MAGIC) {
logInternal("Bad magic number 0x%X; message "
"discarded. Caller may hang.",
datap.vN->sdb_magic);
HUnlock(datahandle); /* ignore errors */
continue;
}
/*
* Do the library and daemon agree on the format of the
* SyslogDataBuffer_t structure?
*/
if (datap.vN->sdb_version != _SYSLOG_STRUCT_VERSION) {
logInternal("Message version mismatch. Expected %d "
"got %d. Message discarded. Caller may hang.",
_SYSLOG_STRUCT_VERSION,
datap.vN->sdb_version);
HUnlock(datahandle); /* ignore errors */
continue;
}
/*
* Do we have a facility/priority prefix? It's of the
* form "<nnnnn>rest_of_message", where the angle brackets
* are literals. Set FacPri to this value if present,
* otherwise set it to the default value, user.notice.
*
* This should be changed so that we immediately copy the
* buffer and any other required info, then release the caller.
*/
p = datap.vN->sdb_buffer;
bytesToCopy = datap.vN->sdb_msglen;
if (*p == '<') {
p++;
FacPri = strtol(p, &q, 10);
if (p == q) {
FacPri = LOG_MAKEPRI(LOG_USER, LOG_NOTICE);
--p;
} else if (*q == '>') {
p = q + 1;
} else {
p = q;
}
bytesToCopy -= (p - datap.vN->sdb_buffer);
} else {
FacPri = LOG_MAKEPRI(LOG_USER, LOG_NOTICE);
}
}
/*
* At this point, p points the point in the caller's buffer
* where we should start copying bytes. bytesToCopy
* contains the number of bytes in the callers buffer that
* we should copy.
*
* If the 'needtime' flag is set, we now copy a time stamp
* into our own buffer (the user's buffer is untouched).
*/
if (datap.vN->sdb_needtime) {
time(&Now);
q = ctime(&Now) + 4;
q[16] = '\0';
strcpy(MessageBuffer, q);
q = MessageBuffer + 16;
MessageBufferLen = 16;
} else {
q = MessageBuffer;
*q = '\0';
MessageBufferLen = 0;
}
/*
* Now we can also say that q points to the point in
* MessageBuffer to where we should start copying characters.
* MessageBufferLen is the number of characters we've used
* in MessageBuffer.
*
* Copy the message to our buffer, minus any prefix, and
* append a newline. Make sure MessageBuffer is NULL-
* terminated.
*/
if (bytesToCopy > _SYSLOG_BUFFERLEN-2) {
bytesToCopy = _SYSLOG_BUFFERLEN-2;
}
MessageBufferLen += bytesToCopy;
if (bytesToCopy == 0) {
q[0] = '\r';
q[1] = '\0';
MessageBufferLen++;
} else {
memcpy(q, p, bytesToCopy);
if (q[bytesToCopy-1] != '\r') {
q[bytesToCopy++] = '\r';
MessageBufferLen++;
}
q[bytesToCopy] = '\0';
}
/*
* We have our own version of the message now, so we can
* release the caller's data buffer and then proceed to print
* our own copy.
*
* See the comments in the syslog(3) code as to why we do
* it with a busy-wait.
*/
datap.vN->sdb_busywait = 0;
/* print the message */
logMessage(FacPri, MessageBuffer, MessageBufferLen);
#endif /* BORK */
}
/*NOTREACHED*/
return 0;
}
static void
handleVersionZero (SyslogDataBuffer0_t *dataptr0)
{
int *offset; /* offset from dataptr0 of current string */
int *length;
char *string;
if (dataptr0->sdb0_numstrings == 0) {
logInternal("[zero length message]");
return;
}
offset = (int *) ((char *) dataptr0 + sizeof(SyslogDataBuffer0_t));
length = (int *) ((char *) dataptr0 + *offset);
string = ((char *) length) + sizeof(int);
logMessage(dataptr0->sdb0_prio, string, *length);
if (dataptr0->sdb0_numstrings > 1) {
logInternal("Cannot handle multiple strings. Last %d ignored",
dataptr0->sdb0_numstrings -1);
}
return;
}
/*
* Print the message <msg> of length <len> to the relevent files based on
* the facility/priority value <facpri>.
*
* This routine is still a kludge. We need information parsed from the
* /etc/syslog.conf file to be referenced here.
*
* The following globals must already be set:
* LogConsole (temporary kludge)
* LogFile (temporary kludge)
*/
static int
logMessage (int facpri, const char *msg, int len) {
int result = 0;
if (LogConsole) {
if (writeConsole(msg, len) != 0) {
result = 1;
}
}
if (LogFile != NULL) {
int logfd;
if ((logfd = open(LogFile, O_RDWR | O_APPEND)) > -1) {
/*
* Don't throw an error if it fails; the file may
* not exist.
*
* Always having to open/write/close the file is
* a pain in the ass, but on the GS we need to do
* this to ensure that the file remains readable
* to other processes.
*/
if (write(logfd, msg, len) < 0) {
result = 1;
}
close(logfd);
}
}
return result;
}
/*
* Choke and puke.
* If <message> is not the empty string, print it out to console, first,
* prefixed by "syslogd: ".
*
* Careful what you call here; we may be inside a signal handler.
*/
#if 0
static void
die (const char *message)
{
#define BUFFER_LEN 80
#define HEADER "syslogd: "
static char buffer[BUFFER_LEN];
if ((message != NULL) && (*message != '\0')) {
sprintmt(buffer, BUFFER_LEN, "syslogd: %s\r", message);
writeConsole(buffer, strlen(buffer));
}
kill(getpid(), SIGKILL);
}
#endif
#pragma databank 1
#define MSG_QUIT "received a quit signal\r"
#if 0
static void
handle_HUP (int sig, int code) {
#define MSG_HUP "received a SIGHUP\r"
/* we should re-read the config file here */
writeConsole(MSG_HUP, sizeof(MSG_HUP)-1);
}
#endif
static void
handle_TERM (int sig, int code) {
#if 1
if (Port != -1) {
pdelete(Port, NULL);
}
kill(getpid(), SIGKILL);
#else
if (pdelete(Port, NULL) != 0) {
die("failed to delete port on exit");
}
die(""); /* don't print a message */
#endif
}
#pragma databank 0
static int
writeConsole (const char *buf, size_t size) {
#if 1
int fd;
if ((fd = open(_PATH_CONSOLE, O_WRONLY)) < 0) {
return -1;
}
/* we should probably loop to ensure that the write completes */
write(fd, buf, size);
close(fd);
return 0;
#else
#endif
}
#pragma optimize 78
#pragma debug 0
void
logInternal (const char *message, ...) {
#define BUFFER_SIZE 256
static char buffer[BUFFER_SIZE];
time_t now;
va_list ap;
char *p;
va_start(ap, message);
/*
* Put our prefix at the front of the message.
*/
time(&now);
p = ctime(&now) + 4;
p[16] = '\0';
p = sprintmt(buffer, BUFFER_SIZE, "%s syslogd[%d]: ", p, getpid());
#if 1
p = vsprintmt(p, BUFFER_SIZE - (p - buffer), message, ap);
#else
p = vsprintmt(p, p - buffer, message, ap);
#endif
#if 0
/* this is the one we *should* be using */
logMessage(LOG_MAKEPRI(LOG_DAEMON, LOG_CRIT), buffer, p - buffer);
#else
/* for debugging only */
if ((p - buffer) < BUFFER_SIZE) {
*p++ = '\r';
*p = '\0';
} else {
*(p-1) = '\r';
}
writeConsole(buffer, p-buffer);
#endif
va_end(ap);
}
Reference in New Issue View Git Blame Copy Permalink