/***************************************************************************
*
* Copyright (c) 1999 Balázs Scheidler
* Copyright (c) 1999-2001 BalaBit IT Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* Inspired by nsyslog, originally written by Darren Reed.
*
* $Id: afstreams.c,v 1.16.4.2 2004/05/13 11:33:36 bazsi Exp $
*
***************************************************************************/
#include "afstreams.h"
#include "sources.h"
#include "format.h"
#include "cfgfile.h"
#include "afstreams.c.x"
#if HAVE_SUN_STREAMS
#include <sys/types.h>
#include <sys/stat.h>
#include <stropts.h>
#include <sys/strlog.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <alloca.h>
#if HAVE_SUN_DOOR && HAVE_DOOR_H
#include <door.h>
#endif
/* CLASS:
(class
(name door_fd)
(super resource)
(vars
(fd simple int)))
*/
#if HAVE_SUN_DOOR
static void do_kill_door(struct resource *r)
{
CAST(door_fd, self, r);
door_revoke(self->fd);
close(self->fd);
}
static struct door_fd *make_door_fd(int fd)
{
NEW(door_fd, f);
f->super.kill = do_kill_door;
f->fd = fd;
return f;
}
#endif
/* CLASS:
(class
(name stream_fd)
(super nonblocking_fd)
(vars
(bad_hostname special-struct regex_t #f regfree)
(max_log_line . UINT32)
(pipe object log_handler)))
*/
static void prepare_stream_fd(struct nonblocking_fd *fd)
{
if (fd->to_be_closed)
kill_fd(fd);
}
static int do_stream_read(int fd, UINT32 *pri, UINT32 length, UINT8 *buf)
{
struct strbuf ctl, data;
struct log_ctl lc;
int flags;
int res;
ctl.maxlen = ctl.len = sizeof(lc);
ctl.buf = (char *) &lc;
data.maxlen = length;
data.len = 0;
data.buf = buf;
flags = 0;
res = getmsg(fd, &ctl, &data, &flags);
if ((res & MORECTL) == 0) {
if (res & MOREDATA) {
werror("do_stream_read: STREAMS device gave too long line\n");
}
*pri = lc.pri;
}
else {
werror("do_stream_read: getmsg() trying to return too much ctl data, res=%i %z\n", res, strerror(errno));
return A_FAIL;
}
return data.len;
}
static void stream_read_callback(struct nonblocking_fd *fd)
{
CAST(stream_fd, self, fd);
char *line = alloca(self->max_log_line + 1);
UINT32 pri;
int n;
n = do_stream_read(self->super.fd, &pri, self->max_log_line, line);
if (n < 0) {
close_fd(fd, CLOSE_EOF);
return;
}
{
UINT8 *eol, *bol;
UINT32 length;
struct log_info *li;
bol = line;
eol = memchr(bol, '\n', n);
if (!eol) eol = memchr(bol, '\0', n);
if (!eol) {
/* FIXME: there must be space for this '\0' as we
* specified sizeof(buf) - 1 when reading the message
*/
eol = &line[n];
line[n] = '\0';
n++;
}
while (eol) {
if (*bol == '\r') {
bol++;
n--;
}
length = eol - bol;
if (length) {
li = make_log_info(length, bol, NULL, 0, &self->bad_hostname);
li->pri = pri;
HANDLE_LOG(self->pipe, li);
}
n -= length + 1;
bol = eol + 1;
eol = memchr(bol, '\n', n);
if (!eol) eol = memchr(bol, '\0', n);
}
}
}
struct nonblocking_fd *io_stream_get(struct io_backend *backend,
int fd,
UINT8 *hostname_re,
UINT32 max_log_line,
struct log_handler *pipe)
{
NEW(stream_fd, f);
init_file(backend, &f->super, fd, NULL);
f->super.prepare = prepare_stream_fd;
f->super.read = stream_read_callback;
f->super.want_read = 1;
f->pipe = pipe;
f->max_log_line = max_log_line;
if (hostname_re == NULL)
regcomp(&f->bad_hostname, "^$", REG_NOSUB | REG_EXTENDED);
else
regcomp(&f->bad_hostname, hostname_re, REG_NOSUB | REG_EXTENDED);
return &f->super;
}
/* CLASS:
(class
(name afstreams_source)
(super log_source_driver)
(vars
(name string)
(door_name string)
(stream_fd object nonblocking_fd)
(door object door_fd)))
*/
#if HAVE_SUN_DOOR
void afstreams_door_server_proc(void *cookie, char *argp, size_t arg_size, door_desc_t *dp, size_t n_desc)
{
door_return(NULL, 0, NULL, 0);
return;
}
#endif
void afstreams_set_sundoor(struct log_source_driver *c, const char *door)
{
CAST(afstreams_source, self, c);
self->door_name = c_format_cstring("%z", door);
}
static int
do_init_afstreams_source(struct log_handler *c,
struct syslog_config *cfg,
struct persistent_config *persistent)
{
CAST(afstreams_source, self, c);
int fd;
fd = open(self->name->data, O_RDONLY | O_NOCTTY | O_NONBLOCK);
if (fd != -1) {
struct strioctl ioc;
#if HAVE_SUN_DOOR
struct stat st;
#endif
memset(&ioc, 0, sizeof(ioc));
ioc.ic_cmd = I_CONSLOG;
if (ioctl(fd, I_STR, &ioc) < 0) {
werror("do_init_afstreams_source: Cannot enable console logging on sun-stream %S (%z)\n", self->name, strerror(errno));
close(fd);
return ST_FAIL | ST_QUIT;
}
self->stream_fd = io_stream_get(cfg->backend, fd, cfg->bad_hostname, cfg->log_msg_size, c);
REMEMBER_RESOURCE(cfg->resources, &self->stream_fd->super);
#if HAVE_SUN_DOOR
if (self->door_name) {
if (stat(self->door_name->data, &st) == -1) {
fd = creat(self->door_name->data, 0666);
if (fd == -1) {
werror("do_init_afstreams_source: cannot create door file %S (%z)\n", self->door_name, strerror(errno));
return ST_FAIL | ST_QUIT;
}
close(fd);
}
fdetach(self->door_name->data);
fd = door_create(afstreams_door_server_proc, NULL, 0);
if (fd == -1) {
werror("do_init_afstreams_source: Cannot initialize door server %S (%z)\n", self->name, strerror(errno));
return ST_FAIL | ST_QUIT;
}
if (fattach(fd, self->door_name->data) == -1) {
werror("do_init_afstreams_source: Cannot attach door to %S (%z)\n", self->name, strerror(errno));
close(fd);
return ST_FAIL | ST_QUIT;
}
self->door = make_door_fd(fd);
REMEMBER_RESOURCE(cfg->resources, &self->door->super);
}
#else
if (self->door_name) {
close_fd(self->stream_fd, 0);
werror("sun-door support is not compiled in, door=%S\n", self->door_name);
return ST_FAIL | ST_QUIT;
}
#endif
}
else {
werror("do_init_afstreams_source: Cannot open sun-stream %S (%z)\n", self->name, strerror(errno));
return ST_FAIL | ST_QUIT;
}
return ST_OK | ST_GOON;
}
static void do_handle_afstreams_source(struct log_handler *c, struct log_info *log)
{
CAST(afstreams_source, self, c);
log->flags |= LF_LOCAL;
HANDLE_LOG(self->super.super.next, log);
}
struct log_source_driver *make_afstreams_source(const char *name)
{
NEW(afstreams_source, self);
self->super.super.super.init = do_init_afstreams_source;
self->super.super.super.handler = do_handle_afstreams_source;
self->name = c_format_cstring("%z", name);
return &self->super;
}
#else
void afstreams_set_sundoor(struct log_source_driver *c, const char *door_name)
{
}
static int
do_init_afstreams_source(struct log_handler *c,
struct syslog_config *cfg,
struct persistent_config *persistent)
{
CAST(afstreams_source, self, c);
werror("sun-streams support not compiled in (STREAM=%S)\n", self->name);
return ST_FAIL | ST_QUIT;
}
struct log_source_driver *make_afstreams_source(const char *name)
{
NEW(afstreams_source, self);
self->super.super.super.init = do_init_afstreams_source;
self->name = c_format_cstring("%z", name);
return &self->super;
}
#endif