1994-05-26 05:23:31 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1983, 1988, 1993, 1994
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef lint
|
1995-10-12 17:18:39 +00:00
|
|
|
static const char copyright[] =
|
1994-05-26 05:23:31 +00:00
|
|
|
"@(#) Copyright (c) 1983, 1988, 1993, 1994\n\
|
|
|
|
The Regents of the University of California. All rights reserved.\n";
|
1997-10-20 12:55:49 +00:00
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
#ifndef lint
|
|
|
|
#if 0
|
1994-05-26 05:23:31 +00:00
|
|
|
static char sccsid[] = "@(#)syslogd.c 8.3 (Berkeley) 4/4/94";
|
1997-10-20 12:55:49 +00:00
|
|
|
#endif
|
1994-05-26 05:23:31 +00:00
|
|
|
#endif /* not lint */
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/*
|
|
|
|
* syslogd -- log system messages
|
|
|
|
*
|
|
|
|
* This program implements a system log. It takes a series of lines.
|
|
|
|
* Each line may have a priority, signified as "<n>" as
|
|
|
|
* the first characters of the line. If this is
|
|
|
|
* not present, a default priority is used.
|
|
|
|
*
|
|
|
|
* To kill syslogd, send a signal 15 (terminate). A signal 1 (hup) will
|
|
|
|
* cause it to reread its configuration file.
|
|
|
|
*
|
|
|
|
* Defined Constants:
|
|
|
|
*
|
2004-05-29 23:14:03 +00:00
|
|
|
* MAXLINE -- the maximum line length that can be handled.
|
1994-05-26 05:23:31 +00:00
|
|
|
* DEFUPRI -- the default priority for user messages
|
|
|
|
* DEFSPRI -- the default priority for kernel messages
|
|
|
|
*
|
|
|
|
* Author: Eric Allman
|
|
|
|
* extensive changes by Ralph Campbell
|
|
|
|
* more extensive changes by Eric Allman (again)
|
1994-12-29 22:02:25 +00:00
|
|
|
* Extension to log by program name as well as facility and priority
|
|
|
|
* by Peter da Silva.
|
1998-07-22 06:15:19 +00:00
|
|
|
* -u and -v by Harlan Stenn.
|
|
|
|
* Priority comparison code by Harlan Stenn.
|
1994-05-26 05:23:31 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#define MAXLINE 1024 /* maximum line length */
|
|
|
|
#define MAXSVLINE 120 /* maximum saved line length */
|
|
|
|
#define DEFUPRI (LOG_USER|LOG_NOTICE)
|
|
|
|
#define DEFSPRI (LOG_KERN|LOG_CRIT)
|
|
|
|
#define TIMERINTVL 30 /* interval for checking flush, mark */
|
2004-05-29 23:14:03 +00:00
|
|
|
#define TTYMSGTIME 1 /* timeout passed to ttymsg */
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <sys/socket.h>
|
1997-02-22 12:59:36 +00:00
|
|
|
#include <sys/queue.h>
|
1994-05-26 05:23:31 +00:00
|
|
|
#include <sys/uio.h>
|
|
|
|
#include <sys/un.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/resource.h>
|
1994-12-29 22:02:25 +00:00
|
|
|
#include <sys/syslimits.h>
|
2003-05-17 20:05:18 +00:00
|
|
|
#include <sys/types.h>
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netdb.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
|
|
|
|
#include <ctype.h>
|
1997-10-20 12:55:49 +00:00
|
|
|
#include <err.h>
|
1994-05-26 05:23:31 +00:00
|
|
|
#include <errno.h>
|
|
|
|
#include <fcntl.h>
|
2003-05-17 20:05:18 +00:00
|
|
|
#include <libutil.h>
|
2002-10-27 17:46:53 +00:00
|
|
|
#include <limits.h>
|
2002-03-24 05:48:37 +00:00
|
|
|
#include <paths.h>
|
1994-05-26 05:23:31 +00:00
|
|
|
#include <signal.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
1997-05-03 22:17:43 +00:00
|
|
|
#include <sysexits.h>
|
1994-05-26 05:23:31 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <utmp.h>
|
2001-09-09 14:25:02 +00:00
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
#include "pathnames.h"
|
2001-09-09 14:25:02 +00:00
|
|
|
#include "ttymsg.h"
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
#define SYSLOG_NAMES
|
|
|
|
#include <sys/syslog.h>
|
1996-10-28 08:25:13 +00:00
|
|
|
|
1995-10-12 17:18:39 +00:00
|
|
|
const char *ConfFile = _PATH_LOGCONF;
|
|
|
|
const char *PidFile = _PATH_LOGPID;
|
|
|
|
const char ctty[] = _PATH_CONSOLE;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
#define dprintf if (Debug) printf
|
|
|
|
|
|
|
|
#define MAXUNAMES 20 /* maximum number of user names */
|
|
|
|
|
2004-11-04 22:20:21 +00:00
|
|
|
/*
|
|
|
|
* Unix sockets.
|
2004-11-04 23:09:57 +00:00
|
|
|
* We have two default sockets, one with 666 permissions,
|
2004-11-18 12:20:52 +00:00
|
|
|
* and one for privileged programs.
|
2004-11-04 22:20:21 +00:00
|
|
|
*/
|
|
|
|
struct funix {
|
|
|
|
int s;
|
|
|
|
char *name;
|
|
|
|
mode_t mode;
|
|
|
|
STAILQ_ENTRY(funix) next;
|
|
|
|
};
|
2004-11-04 23:09:57 +00:00
|
|
|
struct funix funix_secure = { -1, _PATH_LOG_PRIV, S_IRUSR | S_IWUSR,
|
2004-11-04 22:20:21 +00:00
|
|
|
{ NULL } };
|
2004-11-04 23:09:57 +00:00
|
|
|
struct funix funix_default = { -1, _PATH_LOG, DEFFILEMODE,
|
|
|
|
{ &funix_secure } };
|
1998-06-25 19:39:19 +00:00
|
|
|
|
2004-11-04 22:20:21 +00:00
|
|
|
STAILQ_HEAD(, funix) funixes = { &funix_default,
|
2004-11-04 23:09:57 +00:00
|
|
|
&(funix_secure.next.stqe_next) };
|
1998-06-25 19:39:19 +00:00
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/*
|
|
|
|
* Flags to logmsg().
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define IGN_CONS 0x001 /* don't print on console */
|
|
|
|
#define SYNC_FILE 0x002 /* do fsync on file after printing */
|
|
|
|
#define ADDDATE 0x004 /* add a date to the message */
|
|
|
|
#define MARK 0x008 /* this message is a mark */
|
1998-06-24 23:50:20 +00:00
|
|
|
#define ISKERNEL 0x010 /* kernel generated message */
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This structure represents the files that will have log
|
|
|
|
* copies printed.
|
2004-05-30 00:02:19 +00:00
|
|
|
* We require f_file to be valid if f_type is F_FILE, F_CONSOLE, F_TTY
|
|
|
|
* or if f_type if F_PIPE and f_pid > 0.
|
1994-05-26 05:23:31 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
struct filed {
|
|
|
|
struct filed *f_next; /* next in linked list */
|
|
|
|
short f_type; /* entry type, see below */
|
|
|
|
short f_file; /* file descriptor */
|
|
|
|
time_t f_time; /* time this was last written */
|
2000-07-24 14:10:17 +00:00
|
|
|
char *f_host; /* host from which to recd. */
|
1994-05-26 05:23:31 +00:00
|
|
|
u_char f_pmask[LOG_NFACILITIES+1]; /* priority mask */
|
1998-07-22 06:15:19 +00:00
|
|
|
u_char f_pcmp[LOG_NFACILITIES+1]; /* compare priority */
|
|
|
|
#define PRI_LT 0x1
|
|
|
|
#define PRI_EQ 0x2
|
|
|
|
#define PRI_GT 0x4
|
1994-12-29 22:02:25 +00:00
|
|
|
char *f_program; /* program this applies to */
|
1994-05-26 05:23:31 +00:00
|
|
|
union {
|
|
|
|
char f_uname[MAXUNAMES][UT_NAMESIZE+1];
|
|
|
|
struct {
|
2001-03-09 21:24:13 +00:00
|
|
|
char f_hname[MAXHOSTNAMELEN];
|
2000-12-16 18:25:48 +00:00
|
|
|
struct addrinfo *f_addr;
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
} f_forw; /* forwarding address */
|
|
|
|
char f_fname[MAXPATHLEN];
|
1997-02-22 12:59:36 +00:00
|
|
|
struct {
|
|
|
|
char f_pname[MAXPATHLEN];
|
|
|
|
pid_t f_pid;
|
|
|
|
} f_pipe;
|
1994-05-26 05:23:31 +00:00
|
|
|
} f_un;
|
|
|
|
char f_prevline[MAXSVLINE]; /* last message logged */
|
|
|
|
char f_lasttime[16]; /* time of last occurrence */
|
2001-03-09 21:24:13 +00:00
|
|
|
char f_prevhost[MAXHOSTNAMELEN]; /* host from which recd. */
|
1994-05-26 05:23:31 +00:00
|
|
|
int f_prevpri; /* pri of f_prevline */
|
|
|
|
int f_prevlen; /* length of f_prevline */
|
|
|
|
int f_prevcount; /* repetition cnt of prevline */
|
2001-09-09 14:25:02 +00:00
|
|
|
u_int f_repeatcount; /* number of "repeated" msgs */
|
2004-05-30 10:04:03 +00:00
|
|
|
int f_flags; /* file-specific flags */
|
|
|
|
#define FFLAG_SYNC 0x01
|
2004-07-04 19:13:58 +00:00
|
|
|
#define FFLAG_NEEDSYNC 0x02
|
1994-05-26 05:23:31 +00:00
|
|
|
};
|
|
|
|
|
1997-02-22 12:59:36 +00:00
|
|
|
/*
|
|
|
|
* Queue of about-to-be dead processes we should watch out for.
|
|
|
|
*/
|
|
|
|
|
2000-05-26 02:09:24 +00:00
|
|
|
TAILQ_HEAD(stailhead, deadq_entry) deadq_head;
|
1997-02-22 12:59:36 +00:00
|
|
|
struct stailhead *deadq_headp;
|
|
|
|
|
|
|
|
struct deadq_entry {
|
|
|
|
pid_t dq_pid;
|
|
|
|
int dq_timeout;
|
2000-05-26 02:09:24 +00:00
|
|
|
TAILQ_ENTRY(deadq_entry) dq_entries;
|
1997-02-22 12:59:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The timeout to apply to processes waiting on the dead queue. Unit
|
|
|
|
* of measure is `mark intervals', i.e. 20 minutes by default.
|
|
|
|
* Processes on the dead queue will be terminated after that time.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define DQ_TIMO_INIT 2
|
|
|
|
|
|
|
|
typedef struct deadq_entry *dq_t;
|
|
|
|
|
|
|
|
|
1997-05-03 22:17:43 +00:00
|
|
|
/*
|
|
|
|
* Struct to hold records of network addresses that are allowed to log
|
|
|
|
* to us.
|
|
|
|
*/
|
|
|
|
struct allowedpeer {
|
|
|
|
int isnumeric;
|
|
|
|
u_short port;
|
|
|
|
union {
|
|
|
|
struct {
|
2000-12-16 18:25:48 +00:00
|
|
|
struct sockaddr_storage addr;
|
|
|
|
struct sockaddr_storage mask;
|
1997-05-03 22:17:43 +00:00
|
|
|
} numeric;
|
|
|
|
char *name;
|
|
|
|
} u;
|
|
|
|
#define a_addr u.numeric.addr
|
|
|
|
#define a_mask u.numeric.mask
|
|
|
|
#define a_name u.name
|
|
|
|
};
|
|
|
|
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/*
|
|
|
|
* Intervals at which we flush out "message repeated" messages,
|
|
|
|
* in seconds after previous message is logged. After each flush,
|
|
|
|
* we move to the next interval until we reach the largest.
|
|
|
|
*/
|
|
|
|
int repeatinterval[] = { 30, 120, 600 }; /* # of secs before flush */
|
|
|
|
#define MAXREPEAT ((sizeof(repeatinterval) / sizeof(repeatinterval[0])) - 1)
|
|
|
|
#define REPEATTIME(f) ((f)->f_time + repeatinterval[(f)->f_repeatcount])
|
|
|
|
#define BACKOFF(f) { if (++(f)->f_repeatcount > MAXREPEAT) \
|
|
|
|
(f)->f_repeatcount = MAXREPEAT; \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* values for f_type */
|
|
|
|
#define F_UNUSED 0 /* unused entry */
|
|
|
|
#define F_FILE 1 /* regular file */
|
|
|
|
#define F_TTY 2 /* terminal */
|
|
|
|
#define F_CONSOLE 3 /* console terminal */
|
|
|
|
#define F_FORW 4 /* remote machine */
|
|
|
|
#define F_USERS 5 /* list of users */
|
|
|
|
#define F_WALL 6 /* everyone logged on */
|
1997-02-22 12:59:36 +00:00
|
|
|
#define F_PIPE 7 /* pipe to program */
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2001-09-09 14:25:02 +00:00
|
|
|
const char *TypeNames[8] = {
|
1994-05-26 05:23:31 +00:00
|
|
|
"UNUSED", "FILE", "TTY", "CONSOLE",
|
1997-02-22 12:59:36 +00:00
|
|
|
"FORW", "USERS", "WALL", "PIPE"
|
1994-05-26 05:23:31 +00:00
|
|
|
};
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static struct filed *Files; /* Log files that we write to */
|
|
|
|
static struct filed consfile; /* Console */
|
|
|
|
|
|
|
|
static int Debug; /* debug flag */
|
|
|
|
static int resolve = 1; /* resolve hostname */
|
|
|
|
static char LocalHostName[MAXHOSTNAMELEN]; /* our hostname */
|
2004-05-26 21:14:13 +00:00
|
|
|
static const char *LocalDomain; /* our local domain name */
|
2002-03-24 05:48:37 +00:00
|
|
|
static int *finet; /* Internet datagram socket */
|
|
|
|
static int fklog = -1; /* /dev/klog */
|
|
|
|
static int Initialized; /* set when we have initialized ourselves */
|
|
|
|
static int MarkInterval = 20 * 60; /* interval between marks in seconds */
|
|
|
|
static int MarkSeq; /* mark sequence number */
|
|
|
|
static int SecureMode; /* when true, receive only unix domain socks */
|
2000-12-16 18:25:48 +00:00
|
|
|
#ifdef INET6
|
2002-03-24 05:48:37 +00:00
|
|
|
static int family = PF_UNSPEC; /* protocol family (IPv4, IPv6 or both) */
|
2000-12-16 18:25:48 +00:00
|
|
|
#else
|
2002-03-24 05:48:37 +00:00
|
|
|
static int family = PF_INET; /* protocol family (IPv4 only) */
|
2000-12-16 18:25:48 +00:00
|
|
|
#endif
|
2002-03-24 05:48:37 +00:00
|
|
|
static int send_to_all; /* send message to all IPv4/IPv6 addresses */
|
|
|
|
static int use_bootfile; /* log entire bootfile for every kern msg */
|
|
|
|
static int no_compress; /* don't compress messages (1=pipes, 2=all) */
|
2006-03-06 10:36:33 +00:00
|
|
|
static int logflags = O_WRONLY|O_APPEND; /* flags used to open log files */
|
1996-07-22 16:35:50 +00:00
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static char bootfile[MAXLINE+1]; /* booted kernel file */
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
struct allowedpeer *AllowedPeers; /* List of allowed peers */
|
|
|
|
static int NumAllowed; /* Number of entries in AllowedPeers */
|
1997-05-03 22:17:43 +00:00
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static int UniquePriority; /* Only log specified priority? */
|
|
|
|
static int LogFacPri; /* Put facility and priority in log message: */
|
1998-07-22 06:15:19 +00:00
|
|
|
/* 0=no, 1=numeric, 2=names */
|
2002-03-24 05:48:37 +00:00
|
|
|
static int KeepKernFac; /* Keep remotely logged kernel facility */
|
2004-07-04 19:13:58 +00:00
|
|
|
static int needdofsync = 0; /* Are any file(s) waiting to be fsynced? */
|
2005-08-24 17:26:26 +00:00
|
|
|
static struct pidfh *pfh;
|
1998-07-22 06:15:19 +00:00
|
|
|
|
2001-09-01 07:57:35 +00:00
|
|
|
volatile sig_atomic_t MarkSet, WantDie;
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static int allowaddr(char *);
|
|
|
|
static void cfline(const char *, struct filed *,
|
|
|
|
const char *, const char *);
|
|
|
|
static const char *cvthname(struct sockaddr *);
|
|
|
|
static void deadq_enter(pid_t, const char *);
|
|
|
|
static int deadq_remove(pid_t);
|
|
|
|
static int decode(const char *, CODE *);
|
|
|
|
static void die(int);
|
|
|
|
static void dodie(int);
|
2004-07-04 19:52:48 +00:00
|
|
|
static void dofsync(void);
|
2002-03-24 05:48:37 +00:00
|
|
|
static void domark(int);
|
|
|
|
static void fprintlog(struct filed *, int, const char *);
|
|
|
|
static int *socksetup(int, const char *);
|
|
|
|
static void init(int);
|
|
|
|
static void logerror(const char *);
|
|
|
|
static void logmsg(int, const char *, const char *, int);
|
|
|
|
static void log_deadchild(pid_t, int, const char *);
|
|
|
|
static void markit(void);
|
2003-05-04 22:05:40 +00:00
|
|
|
static int skip_message(const char *, const char *, int);
|
2002-03-24 05:48:37 +00:00
|
|
|
static void printline(const char *, char *);
|
|
|
|
static void printsys(char *);
|
|
|
|
static int p_open(const char *, pid_t *);
|
|
|
|
static void readklog(void);
|
|
|
|
static void reapchild(int);
|
2002-03-24 05:24:04 +00:00
|
|
|
static void usage(void);
|
2002-03-24 05:48:37 +00:00
|
|
|
static int validate(struct sockaddr *, const char *);
|
2002-03-24 05:24:04 +00:00
|
|
|
static void unmapped(struct sockaddr *);
|
2002-03-24 05:48:37 +00:00
|
|
|
static void wallmsg(struct filed *, struct iovec *);
|
|
|
|
static int waitdaemon(int, int, int);
|
|
|
|
static void timedout(int);
|
2004-11-11 09:39:04 +00:00
|
|
|
static void double_rbuf(int);
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
int
|
2002-03-24 05:48:37 +00:00
|
|
|
main(int argc, char *argv[])
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
2001-09-01 07:57:35 +00:00
|
|
|
int ch, i, fdsrmax = 0, l;
|
1994-05-26 05:23:31 +00:00
|
|
|
struct sockaddr_un sunx, fromunix;
|
2000-12-16 18:25:48 +00:00
|
|
|
struct sockaddr_storage frominet;
|
2001-09-01 07:57:35 +00:00
|
|
|
fd_set *fdsr = NULL;
|
2001-09-09 14:25:02 +00:00
|
|
|
char line[MAXLINE + 1];
|
|
|
|
const char *bindhostname, *hname;
|
1996-10-05 15:20:51 +00:00
|
|
|
struct timeval tv, *tvp;
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
struct sigaction sact;
|
2004-11-04 22:20:21 +00:00
|
|
|
struct funix *fx, *fx1;
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
sigset_t mask;
|
2005-08-24 17:26:26 +00:00
|
|
|
pid_t ppid = 1, spid;
|
2000-01-14 15:09:06 +00:00
|
|
|
socklen_t len;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2001-09-01 08:42:49 +00:00
|
|
|
bindhostname = NULL;
|
2006-03-06 10:36:33 +00:00
|
|
|
while ((ch = getopt(argc, argv, "46Aa:b:cCdf:kl:m:nop:P:sS:uv")) != -1)
|
2000-08-03 15:19:27 +00:00
|
|
|
switch (ch) {
|
2000-12-16 18:25:48 +00:00
|
|
|
case '4':
|
|
|
|
family = PF_INET;
|
|
|
|
break;
|
|
|
|
#ifdef INET6
|
|
|
|
case '6':
|
|
|
|
family = PF_INET6;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
case 'A':
|
|
|
|
send_to_all++;
|
|
|
|
break;
|
1997-05-03 22:17:43 +00:00
|
|
|
case 'a': /* allow specific network addresses only */
|
|
|
|
if (allowaddr(optarg) == -1)
|
|
|
|
usage();
|
|
|
|
break;
|
2001-09-01 08:42:49 +00:00
|
|
|
case 'b':
|
|
|
|
bindhostname = optarg;
|
|
|
|
break;
|
2002-01-05 07:34:52 +00:00
|
|
|
case 'c':
|
|
|
|
no_compress++;
|
|
|
|
break;
|
2006-03-06 10:36:33 +00:00
|
|
|
case 'C':
|
|
|
|
logflags |= O_CREAT;
|
|
|
|
break;
|
2000-08-03 15:19:27 +00:00
|
|
|
case 'd': /* debug */
|
|
|
|
Debug++;
|
|
|
|
break;
|
1994-05-26 05:23:31 +00:00
|
|
|
case 'f': /* configuration file */
|
|
|
|
ConfFile = optarg;
|
|
|
|
break;
|
2000-10-17 10:19:42 +00:00
|
|
|
case 'k': /* keep remote kern fac */
|
|
|
|
KeepKernFac = 1;
|
|
|
|
break;
|
2000-08-03 15:19:27 +00:00
|
|
|
case 'l':
|
2004-11-04 22:20:21 +00:00
|
|
|
{
|
|
|
|
long perml;
|
|
|
|
mode_t mode;
|
|
|
|
char *name, *ep;
|
|
|
|
|
|
|
|
if (optarg[0] == '/') {
|
|
|
|
mode = DEFFILEMODE;
|
|
|
|
name = optarg;
|
|
|
|
} else if ((name = strchr(optarg, ':')) != NULL) {
|
|
|
|
*name++ = '\0';
|
|
|
|
if (name[0] != '/')
|
|
|
|
errx(1, "socket name must be absolute "
|
|
|
|
"path");
|
|
|
|
if (isdigit(*optarg)) {
|
|
|
|
perml = strtol(optarg, &ep, 8);
|
|
|
|
if (*ep || perml < 0 ||
|
|
|
|
perml & ~(S_IRWXU|S_IRWXG|S_IRWXO))
|
|
|
|
errx(1, "invalid mode %s, exiting",
|
|
|
|
optarg);
|
|
|
|
mode = (mode_t )perml;
|
|
|
|
} else
|
|
|
|
errx(1, "invalid mode %s, exiting",
|
|
|
|
optarg);
|
|
|
|
} else /* doesn't begin with '/', and no ':' */
|
|
|
|
errx(1, "can't parse path %s", optarg);
|
|
|
|
|
|
|
|
if (strlen(name) >= sizeof(sunx.sun_path))
|
|
|
|
errx(1, "%s path too long, exiting", name);
|
|
|
|
if ((fx = malloc(sizeof(struct funix))) == NULL)
|
|
|
|
errx(1, "malloc failed");
|
|
|
|
fx->s = -1;
|
|
|
|
fx->name = name;
|
|
|
|
fx->mode = mode;
|
|
|
|
STAILQ_INSERT_TAIL(&funixes, fx, next);
|
2000-08-03 15:19:27 +00:00
|
|
|
break;
|
2004-11-04 22:20:21 +00:00
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
case 'm': /* mark interval */
|
|
|
|
MarkInterval = atoi(optarg) * 60;
|
|
|
|
break;
|
2000-07-29 04:02:34 +00:00
|
|
|
case 'n':
|
|
|
|
resolve = 0;
|
|
|
|
break;
|
2001-11-27 20:02:18 +00:00
|
|
|
case 'o':
|
|
|
|
use_bootfile = 1;
|
|
|
|
break;
|
1994-05-26 05:23:31 +00:00
|
|
|
case 'p': /* path */
|
2004-05-29 23:27:50 +00:00
|
|
|
if (strlen(optarg) >= sizeof(sunx.sun_path))
|
|
|
|
errx(1, "%s path too long, exiting", optarg);
|
2004-11-04 22:20:21 +00:00
|
|
|
funix_default.name = optarg;
|
1994-05-26 05:23:31 +00:00
|
|
|
break;
|
2001-05-10 15:48:33 +00:00
|
|
|
case 'P': /* path for alt. PID */
|
|
|
|
PidFile = optarg;
|
|
|
|
break;
|
1996-07-22 16:35:50 +00:00
|
|
|
case 's': /* no network mode */
|
|
|
|
SecureMode++;
|
|
|
|
break;
|
2005-04-13 03:19:41 +00:00
|
|
|
case 'S': /* path for privileged originator */
|
|
|
|
if (strlen(optarg) >= sizeof(sunx.sun_path))
|
|
|
|
errx(1, "%s path too long, exiting", optarg);
|
|
|
|
funix_secure.name = optarg;
|
|
|
|
break;
|
1998-07-22 06:15:19 +00:00
|
|
|
case 'u': /* only log specified priority */
|
2004-11-11 09:41:03 +00:00
|
|
|
UniquePriority++;
|
1998-07-22 06:15:19 +00:00
|
|
|
break;
|
|
|
|
case 'v': /* log facility and priority */
|
|
|
|
LogFacPri++;
|
|
|
|
break;
|
1994-05-26 05:23:31 +00:00
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
if ((argc -= optind) != 0)
|
|
|
|
usage();
|
|
|
|
|
2005-08-24 17:26:26 +00:00
|
|
|
pfh = pidfile_open(PidFile, 0600, &spid);
|
|
|
|
if (pfh == NULL) {
|
|
|
|
if (errno == EEXIST)
|
|
|
|
errx(1, "syslogd already running, pid: %d", spid);
|
|
|
|
warn("cannot open pid file");
|
|
|
|
}
|
|
|
|
|
1996-10-05 15:20:51 +00:00
|
|
|
if (!Debug) {
|
|
|
|
ppid = waitdaemon(0, 0, 30);
|
2005-08-24 17:26:26 +00:00
|
|
|
if (ppid < 0) {
|
|
|
|
warn("could not become daemon");
|
|
|
|
pidfile_remove(pfh);
|
|
|
|
exit(1);
|
|
|
|
}
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
1994-05-26 05:23:31 +00:00
|
|
|
setlinebuf(stdout);
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
|
1997-05-03 22:17:43 +00:00
|
|
|
if (NumAllowed)
|
|
|
|
endservent();
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
consfile.f_type = F_CONSOLE;
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(consfile.f_un.f_fname, ctty + sizeof _PATH_DEV - 1,
|
|
|
|
sizeof(consfile.f_un.f_fname));
|
|
|
|
(void)strlcpy(bootfile, getbootfile(), sizeof(bootfile));
|
|
|
|
(void)signal(SIGTERM, dodie);
|
|
|
|
(void)signal(SIGINT, Debug ? dodie : SIG_IGN);
|
|
|
|
(void)signal(SIGQUIT, Debug ? dodie : SIG_IGN);
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
/*
|
|
|
|
* We don't want the SIGCHLD and SIGHUP handlers to interfere
|
|
|
|
* with each other; they are likely candidates for being called
|
|
|
|
* simultaneously (SIGHUP closes pipe descriptor, process dies,
|
|
|
|
* SIGCHLD happens).
|
|
|
|
*/
|
|
|
|
sigemptyset(&mask);
|
|
|
|
sigaddset(&mask, SIGHUP);
|
|
|
|
sact.sa_handler = reapchild;
|
|
|
|
sact.sa_mask = mask;
|
2000-02-29 08:02:29 +00:00
|
|
|
sact.sa_flags = SA_RESTART;
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
(void)sigaction(SIGCHLD, &sact, NULL);
|
1994-05-26 05:23:31 +00:00
|
|
|
(void)signal(SIGALRM, domark);
|
1997-02-22 12:59:36 +00:00
|
|
|
(void)signal(SIGPIPE, SIG_IGN); /* We'll catch EPIPE instead. */
|
1994-05-26 05:23:31 +00:00
|
|
|
(void)alarm(TIMERINTVL);
|
|
|
|
|
1997-04-26 00:00:33 +00:00
|
|
|
TAILQ_INIT(&deadq_head);
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
#ifndef SUN_LEN
|
|
|
|
#define SUN_LEN(unp) (strlen((unp)->sun_path) + 2)
|
|
|
|
#endif
|
2004-11-04 22:20:21 +00:00
|
|
|
STAILQ_FOREACH_SAFE(fx, &funixes, next, fx1) {
|
|
|
|
(void)unlink(fx->name);
|
1998-06-25 19:39:19 +00:00
|
|
|
memset(&sunx, 0, sizeof(sunx));
|
|
|
|
sunx.sun_family = AF_UNIX;
|
2004-11-04 22:20:21 +00:00
|
|
|
(void)strlcpy(sunx.sun_path, fx->name, sizeof(sunx.sun_path));
|
|
|
|
fx->s = socket(AF_UNIX, SOCK_DGRAM, 0);
|
|
|
|
if (fx->s < 0 ||
|
|
|
|
bind(fx->s, (struct sockaddr *)&sunx, SUN_LEN(&sunx)) < 0 ||
|
|
|
|
chmod(fx->name, fx->mode) < 0) {
|
2002-03-24 06:02:10 +00:00
|
|
|
(void)snprintf(line, sizeof line,
|
2004-11-04 22:20:21 +00:00
|
|
|
"cannot create %s", fx->name);
|
1998-06-25 19:39:19 +00:00
|
|
|
logerror(line);
|
2004-11-04 22:20:21 +00:00
|
|
|
dprintf("cannot create %s (%d)\n", fx->name, errno);
|
2004-11-04 23:09:57 +00:00
|
|
|
if (fx == &funix_default || fx == &funix_secure)
|
1998-06-25 19:39:19 +00:00
|
|
|
die(0);
|
2004-11-11 09:39:04 +00:00
|
|
|
else {
|
2004-11-04 22:20:21 +00:00
|
|
|
STAILQ_REMOVE(&funixes, fx, funix, next);
|
2004-11-11 09:39:04 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
double_rbuf(fx->s);
|
1998-06-25 19:39:19 +00:00
|
|
|
}
|
|
|
|
}
|
1999-05-04 18:03:59 +00:00
|
|
|
if (SecureMode <= 1)
|
2001-09-01 08:42:49 +00:00
|
|
|
finet = socksetup(family, bindhostname);
|
2000-12-16 18:25:48 +00:00
|
|
|
|
|
|
|
if (finet) {
|
|
|
|
if (SecureMode) {
|
|
|
|
for (i = 0; i < *finet; i++) {
|
|
|
|
if (shutdown(finet[i+1], SHUT_RD) < 0) {
|
|
|
|
logerror("shutdown");
|
|
|
|
if (!Debug)
|
|
|
|
die(0);
|
|
|
|
}
|
|
|
|
}
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
2000-12-16 18:25:48 +00:00
|
|
|
dprintf("listening on inet and/or inet6 socket\n");
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
dprintf("sending on inet and/or inet6 socket\n");
|
2000-01-14 15:09:06 +00:00
|
|
|
}
|
1998-04-24 17:32:23 +00:00
|
|
|
|
1999-05-02 12:47:09 +00:00
|
|
|
if ((fklog = open(_PATH_KLOG, O_RDONLY, 0)) >= 0)
|
|
|
|
if (fcntl(fklog, F_SETFL, O_NONBLOCK) < 0)
|
|
|
|
fklog = -1;
|
|
|
|
if (fklog < 0)
|
1994-05-26 05:23:31 +00:00
|
|
|
dprintf("can't open %s (%d)\n", _PATH_KLOG, errno);
|
|
|
|
|
|
|
|
/* tuck my process id away */
|
2005-08-24 17:26:26 +00:00
|
|
|
pidfile_write(pfh);
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
dprintf("off & running....\n");
|
|
|
|
|
|
|
|
init(0);
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
/* prevent SIGHUP and SIGCHLD handlers from running in parallel */
|
|
|
|
sigemptyset(&mask);
|
|
|
|
sigaddset(&mask, SIGCHLD);
|
|
|
|
sact.sa_handler = init;
|
|
|
|
sact.sa_mask = mask;
|
2000-02-29 08:02:29 +00:00
|
|
|
sact.sa_flags = SA_RESTART;
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
(void)sigaction(SIGHUP, &sact, NULL);
|
1994-05-26 05:23:31 +00:00
|
|
|
|
1996-10-05 15:20:51 +00:00
|
|
|
tvp = &tv;
|
|
|
|
tv.tv_sec = tv.tv_usec = 0;
|
|
|
|
|
2001-09-01 07:57:35 +00:00
|
|
|
if (fklog != -1 && fklog > fdsrmax)
|
|
|
|
fdsrmax = fklog;
|
|
|
|
if (finet && !SecureMode) {
|
|
|
|
for (i = 0; i < *finet; i++) {
|
|
|
|
if (finet[i+1] != -1 && finet[i+1] > fdsrmax)
|
|
|
|
fdsrmax = finet[i+1];
|
1998-06-25 19:39:19 +00:00
|
|
|
}
|
2001-09-01 07:57:35 +00:00
|
|
|
}
|
2004-11-04 22:20:21 +00:00
|
|
|
STAILQ_FOREACH(fx, &funixes, next)
|
|
|
|
if (fx->s > fdsrmax)
|
|
|
|
fdsrmax = fx->s;
|
2001-09-01 07:57:35 +00:00
|
|
|
|
|
|
|
fdsr = (fd_set *)calloc(howmany(fdsrmax+1, NFDBITS),
|
|
|
|
sizeof(fd_mask));
|
|
|
|
if (fdsr == NULL)
|
|
|
|
errx(1, "calloc fd_set");
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
if (MarkSet)
|
|
|
|
markit();
|
|
|
|
if (WantDie)
|
|
|
|
die(WantDie);
|
|
|
|
|
|
|
|
bzero(fdsr, howmany(fdsrmax+1, NFDBITS) *
|
|
|
|
sizeof(fd_mask));
|
|
|
|
|
|
|
|
if (fklog != -1)
|
|
|
|
FD_SET(fklog, fdsr);
|
2000-12-16 18:25:48 +00:00
|
|
|
if (finet && !SecureMode) {
|
|
|
|
for (i = 0; i < *finet; i++) {
|
2001-09-01 07:57:35 +00:00
|
|
|
if (finet[i+1] != -1)
|
|
|
|
FD_SET(finet[i+1], fdsr);
|
2000-12-16 18:25:48 +00:00
|
|
|
}
|
1998-06-25 19:39:19 +00:00
|
|
|
}
|
2004-11-04 22:20:21 +00:00
|
|
|
STAILQ_FOREACH(fx, &funixes, next)
|
|
|
|
FD_SET(fx->s, fdsr);
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2004-07-04 19:13:58 +00:00
|
|
|
i = select(fdsrmax+1, fdsr, NULL, NULL,
|
|
|
|
needdofsync ? &tv : tvp);
|
2001-09-01 07:57:35 +00:00
|
|
|
switch (i) {
|
|
|
|
case 0:
|
2004-07-04 19:13:58 +00:00
|
|
|
dofsync();
|
|
|
|
needdofsync = 0;
|
1996-10-05 15:20:51 +00:00
|
|
|
if (tvp) {
|
|
|
|
tvp = NULL;
|
|
|
|
if (ppid != 1)
|
|
|
|
kill(ppid, SIGALRM);
|
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
continue;
|
2001-09-01 07:57:35 +00:00
|
|
|
case -1:
|
1994-05-26 05:23:31 +00:00
|
|
|
if (errno != EINTR)
|
|
|
|
logerror("select");
|
|
|
|
continue;
|
|
|
|
}
|
2001-09-01 07:57:35 +00:00
|
|
|
if (fklog != -1 && FD_ISSET(fklog, fdsr))
|
1999-05-02 12:47:09 +00:00
|
|
|
readklog();
|
2000-12-16 18:25:48 +00:00
|
|
|
if (finet && !SecureMode) {
|
|
|
|
for (i = 0; i < *finet; i++) {
|
2001-09-01 07:57:35 +00:00
|
|
|
if (FD_ISSET(finet[i+1], fdsr)) {
|
2000-12-16 18:25:48 +00:00
|
|
|
len = sizeof(frominet);
|
|
|
|
l = recvfrom(finet[i+1], line, MAXLINE,
|
|
|
|
0, (struct sockaddr *)&frominet,
|
|
|
|
&len);
|
|
|
|
if (l > 0) {
|
|
|
|
line[l] = '\0';
|
|
|
|
hname = cvthname((struct sockaddr *)&frominet);
|
|
|
|
unmapped((struct sockaddr *)&frominet);
|
|
|
|
if (validate((struct sockaddr *)&frominet, hname))
|
|
|
|
printline(hname, line);
|
|
|
|
} else if (l < 0 && errno != EINTR)
|
|
|
|
logerror("recvfrom inet");
|
|
|
|
}
|
|
|
|
}
|
1995-05-30 03:57:47 +00:00
|
|
|
}
|
2004-11-04 22:20:21 +00:00
|
|
|
STAILQ_FOREACH(fx, &funixes, next) {
|
|
|
|
if (FD_ISSET(fx->s, fdsr)) {
|
1998-06-25 19:39:19 +00:00
|
|
|
len = sizeof(fromunix);
|
2004-11-04 22:20:21 +00:00
|
|
|
l = recvfrom(fx->s, line, MAXLINE, 0,
|
1998-06-25 19:39:19 +00:00
|
|
|
(struct sockaddr *)&fromunix, &len);
|
|
|
|
if (l > 0) {
|
|
|
|
line[l] = '\0';
|
|
|
|
printline(LocalHostName, line);
|
|
|
|
} else if (l < 0 && errno != EINTR)
|
|
|
|
logerror("recvfrom unix");
|
|
|
|
}
|
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
2001-09-01 07:57:35 +00:00
|
|
|
if (fdsr)
|
|
|
|
free(fdsr);
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
2000-12-16 18:25:48 +00:00
|
|
|
static void
|
2002-03-24 05:48:37 +00:00
|
|
|
unmapped(struct sockaddr *sa)
|
2000-12-16 18:25:48 +00:00
|
|
|
{
|
|
|
|
struct sockaddr_in6 *sin6;
|
2001-09-09 14:25:02 +00:00
|
|
|
struct sockaddr_in sin4;
|
2000-12-16 18:25:48 +00:00
|
|
|
|
|
|
|
if (sa->sa_family != AF_INET6)
|
|
|
|
return;
|
|
|
|
if (sa->sa_len != sizeof(struct sockaddr_in6) ||
|
2001-09-09 14:25:02 +00:00
|
|
|
sizeof(sin4) > sa->sa_len)
|
2000-12-16 18:25:48 +00:00
|
|
|
return;
|
|
|
|
sin6 = (struct sockaddr_in6 *)sa;
|
|
|
|
if (!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
|
|
|
|
return;
|
|
|
|
|
2001-09-09 14:25:02 +00:00
|
|
|
memset(&sin4, 0, sizeof(sin4));
|
|
|
|
sin4.sin_family = AF_INET;
|
|
|
|
sin4.sin_len = sizeof(struct sockaddr_in);
|
|
|
|
memcpy(&sin4.sin_addr, &sin6->sin6_addr.s6_addr[12],
|
|
|
|
sizeof(sin4.sin_addr));
|
|
|
|
sin4.sin_port = sin6->sin6_port;
|
2000-12-16 18:25:48 +00:00
|
|
|
|
2001-09-09 14:25:02 +00:00
|
|
|
memcpy(sa, &sin4, sin4.sin_len);
|
2000-12-16 18:25:48 +00:00
|
|
|
}
|
|
|
|
|
1997-10-20 12:55:49 +00:00
|
|
|
static void
|
2002-03-24 05:48:37 +00:00
|
|
|
usage(void)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
|
|
|
|
2002-10-18 11:48:46 +00:00
|
|
|
fprintf(stderr, "%s\n%s\n%s\n%s\n",
|
2006-03-06 10:36:33 +00:00
|
|
|
"usage: syslogd [-46ACcdknosuv] [-a allowed_peer]",
|
2004-11-11 18:09:00 +00:00
|
|
|
" [-b bind address] [-f config_file]",
|
|
|
|
" [-l log_socket] [-m mark_interval]",
|
|
|
|
" [-P pid_file] [-p log_socket]");
|
1994-05-26 05:23:31 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Take a raw input line, decode the message, and print the message
|
|
|
|
* on the appropriate log files.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
printline(const char *hname, char *msg)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
2004-01-31 17:44:27 +00:00
|
|
|
char *p, *q;
|
|
|
|
long n;
|
1994-05-26 05:23:31 +00:00
|
|
|
int c, pri;
|
2004-01-31 17:44:27 +00:00
|
|
|
char line[MAXLINE + 1];
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
/* test for special codes */
|
|
|
|
p = msg;
|
2004-01-31 17:44:27 +00:00
|
|
|
pri = DEFUPRI;
|
1994-05-26 05:23:31 +00:00
|
|
|
if (*p == '<') {
|
2004-01-31 17:44:27 +00:00
|
|
|
errno = 0;
|
|
|
|
n = strtol(p + 1, &q, 10);
|
|
|
|
if (*q == '>' && n >= 0 && n < INT_MAX && errno == 0) {
|
|
|
|
p = q + 1;
|
|
|
|
pri = n;
|
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
if (pri &~ (LOG_FACMASK|LOG_PRIMASK))
|
|
|
|
pri = DEFUPRI;
|
|
|
|
|
2004-05-29 23:24:18 +00:00
|
|
|
/*
|
|
|
|
* Don't allow users to log kernel messages.
|
|
|
|
* NOTE: since LOG_KERN == 0 this will also match
|
|
|
|
* messages with no facility specified.
|
|
|
|
*/
|
|
|
|
if ((pri & LOG_FACMASK) == LOG_KERN && !KeepKernFac)
|
1994-05-26 05:23:31 +00:00
|
|
|
pri = LOG_MAKEPRI(LOG_USER, LOG_PRI(pri));
|
|
|
|
|
|
|
|
q = line;
|
|
|
|
|
2000-04-18 01:12:27 +00:00
|
|
|
while ((c = (unsigned char)*p++) != '\0' &&
|
2000-09-19 21:22:20 +00:00
|
|
|
q < &line[sizeof(line) - 4]) {
|
2000-04-18 01:12:27 +00:00
|
|
|
if ((c & 0x80) && c < 0xA0) {
|
|
|
|
c &= 0x7F;
|
|
|
|
*q++ = 'M';
|
|
|
|
*q++ = '-';
|
|
|
|
}
|
|
|
|
if (isascii(c) && iscntrl(c)) {
|
2002-03-24 06:02:10 +00:00
|
|
|
if (c == '\n') {
|
1994-05-26 05:23:31 +00:00
|
|
|
*q++ = ' ';
|
2002-03-24 06:02:10 +00:00
|
|
|
} else if (c == '\t') {
|
1994-05-26 05:23:31 +00:00
|
|
|
*q++ = '\t';
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
1994-05-26 05:23:31 +00:00
|
|
|
*q++ = '^';
|
|
|
|
*q++ = c ^ 0100;
|
|
|
|
}
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
1994-05-26 05:23:31 +00:00
|
|
|
*q++ = c;
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
2000-04-18 01:12:27 +00:00
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
*q = '\0';
|
|
|
|
|
|
|
|
logmsg(pri, line, hname, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1999-05-02 12:47:09 +00:00
|
|
|
* Read /dev/klog while data are available, split into lines.
|
1994-05-26 05:23:31 +00:00
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
readklog(void)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
1999-05-02 12:47:09 +00:00
|
|
|
char *p, *q, line[MAXLINE + 1];
|
1999-05-06 13:57:57 +00:00
|
|
|
int len, i;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
1999-05-06 13:57:57 +00:00
|
|
|
len = 0;
|
1999-05-02 12:47:09 +00:00
|
|
|
for (;;) {
|
1999-05-06 13:57:57 +00:00
|
|
|
i = read(fklog, line + len, MAXLINE - 1 - len);
|
2002-03-24 06:02:10 +00:00
|
|
|
if (i > 0) {
|
1999-05-06 13:57:57 +00:00
|
|
|
line[i + len] = '\0';
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
|
|
|
if (i < 0 && errno != EINTR && errno != EAGAIN) {
|
|
|
|
logerror("klog");
|
|
|
|
fklog = -1;
|
|
|
|
}
|
1999-05-02 12:47:09 +00:00
|
|
|
break;
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
1999-05-02 12:47:09 +00:00
|
|
|
|
|
|
|
for (p = line; (q = strchr(p, '\n')) != NULL; p = q + 1) {
|
|
|
|
*q = '\0';
|
|
|
|
printsys(p);
|
|
|
|
}
|
1999-05-06 13:57:57 +00:00
|
|
|
len = strlen(p);
|
|
|
|
if (len >= MAXLINE - 1) {
|
1999-05-02 12:47:09 +00:00
|
|
|
printsys(p);
|
1999-05-06 13:57:57 +00:00
|
|
|
len = 0;
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
2004-11-11 09:41:03 +00:00
|
|
|
if (len > 0)
|
1999-05-06 13:57:57 +00:00
|
|
|
memmove(line, p, len + 1);
|
1999-05-02 12:47:09 +00:00
|
|
|
}
|
1999-05-06 13:57:57 +00:00
|
|
|
if (len > 0)
|
1999-05-02 12:47:09 +00:00
|
|
|
printsys(line);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Take a raw input line from /dev/klog, format similar to syslog().
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
2004-01-26 00:46:46 +00:00
|
|
|
printsys(char *msg)
|
1999-05-02 12:47:09 +00:00
|
|
|
{
|
2004-01-31 17:44:27 +00:00
|
|
|
char *p, *q;
|
|
|
|
long n;
|
|
|
|
int flags, isprintf, pri;
|
1999-05-02 12:47:09 +00:00
|
|
|
|
|
|
|
flags = ISKERNEL | SYNC_FILE | ADDDATE; /* fsync after write */
|
2004-01-26 00:46:46 +00:00
|
|
|
p = msg;
|
2004-01-31 17:44:27 +00:00
|
|
|
pri = DEFSPRI;
|
2004-01-26 00:46:46 +00:00
|
|
|
isprintf = 1;
|
1999-05-02 12:47:09 +00:00
|
|
|
if (*p == '<') {
|
2004-01-31 17:44:27 +00:00
|
|
|
errno = 0;
|
|
|
|
n = strtol(p + 1, &q, 10);
|
|
|
|
if (*q == '>' && n >= 0 && n < INT_MAX && errno == 0) {
|
|
|
|
p = q + 1;
|
2004-01-26 00:46:46 +00:00
|
|
|
pri = n;
|
|
|
|
isprintf = 0;
|
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
2004-01-26 00:46:46 +00:00
|
|
|
/*
|
|
|
|
* Kernel printf's and LOG_CONSOLE messages have been displayed
|
|
|
|
* on the console already.
|
|
|
|
*/
|
|
|
|
if (isprintf || (pri & LOG_FACMASK) == LOG_CONSOLE)
|
|
|
|
flags |= IGN_CONS;
|
1999-05-02 12:47:09 +00:00
|
|
|
if (pri &~ (LOG_FACMASK|LOG_PRIMASK))
|
|
|
|
pri = DEFSPRI;
|
|
|
|
logmsg(pri, p, LocalHostName, flags);
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static time_t now;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2002-11-07 19:53:29 +00:00
|
|
|
/*
|
|
|
|
* Match a program or host name against a specification.
|
|
|
|
* Return a non-0 value if the message must be ignored
|
|
|
|
* based on the specification.
|
|
|
|
*/
|
|
|
|
static int
|
2005-10-17 16:51:06 +00:00
|
|
|
skip_message(const char *name, const char *spec, int checkcase)
|
|
|
|
{
|
2003-02-13 00:08:56 +00:00
|
|
|
const char *s;
|
|
|
|
char prev, next;
|
|
|
|
int exclude = 0;
|
|
|
|
/* Behaviour on explicit match */
|
|
|
|
|
2002-11-07 19:53:29 +00:00
|
|
|
if (spec == NULL)
|
|
|
|
return 0;
|
2003-02-13 00:08:56 +00:00
|
|
|
switch (*spec) {
|
2002-11-07 19:53:29 +00:00
|
|
|
case '-':
|
2003-02-13 00:08:56 +00:00
|
|
|
exclude = 1;
|
|
|
|
/*FALLTHROUGH*/
|
|
|
|
case '+':
|
|
|
|
spec++;
|
|
|
|
break;
|
2002-11-07 19:53:29 +00:00
|
|
|
default:
|
2003-02-13 00:08:56 +00:00
|
|
|
break;
|
2002-11-07 19:53:29 +00:00
|
|
|
}
|
2003-05-04 22:05:40 +00:00
|
|
|
if (checkcase)
|
|
|
|
s = strstr (spec, name);
|
|
|
|
else
|
|
|
|
s = strcasestr (spec, name);
|
2003-02-13 00:08:56 +00:00
|
|
|
|
|
|
|
if (s != NULL) {
|
|
|
|
prev = (s == spec ? ',' : *(s - 1));
|
|
|
|
next = *(s + strlen (name));
|
|
|
|
|
|
|
|
if (prev == ',' && (next == '\0' || next == ','))
|
|
|
|
/* Explicit match: skip iff the spec is an
|
|
|
|
exclusive one. */
|
|
|
|
return exclude;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* No explicit match for this name: skip the message iff
|
|
|
|
the spec is an inclusive one. */
|
|
|
|
return !exclude;
|
2002-11-07 19:53:29 +00:00
|
|
|
}
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/*
|
|
|
|
* Log a message to the appropriate log files, users, etc. based on
|
|
|
|
* the priority.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
logmsg(int pri, const char *msg, const char *from, int flags)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
|
|
|
struct filed *f;
|
1998-06-24 23:50:20 +00:00
|
|
|
int i, fac, msglen, omask, prilev;
|
2001-09-09 14:25:02 +00:00
|
|
|
const char *timestamp;
|
1994-12-29 22:02:25 +00:00
|
|
|
char prog[NAME_MAX+1];
|
1998-06-24 23:50:20 +00:00
|
|
|
char buf[MAXLINE+1];
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
dprintf("logmsg: pri %o, flags %x, from %s, msg %s\n",
|
|
|
|
pri, flags, from, msg);
|
|
|
|
|
|
|
|
omask = sigblock(sigmask(SIGHUP)|sigmask(SIGALRM));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see if msg looks non-standard.
|
|
|
|
*/
|
|
|
|
msglen = strlen(msg);
|
|
|
|
if (msglen < 16 || msg[3] != ' ' || msg[6] != ' ' ||
|
|
|
|
msg[9] != ':' || msg[12] != ':' || msg[15] != ' ')
|
|
|
|
flags |= ADDDATE;
|
|
|
|
|
|
|
|
(void)time(&now);
|
2002-03-24 06:02:10 +00:00
|
|
|
if (flags & ADDDATE) {
|
1994-05-26 05:23:31 +00:00
|
|
|
timestamp = ctime(&now) + 4;
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
1994-05-26 05:23:31 +00:00
|
|
|
timestamp = msg;
|
|
|
|
msg += 16;
|
|
|
|
msglen -= 16;
|
|
|
|
}
|
|
|
|
|
1994-12-29 22:02:25 +00:00
|
|
|
/* skip leading blanks */
|
2000-08-03 15:19:27 +00:00
|
|
|
while (isspace(*msg)) {
|
1994-12-29 22:02:25 +00:00
|
|
|
msg++;
|
|
|
|
msglen--;
|
|
|
|
}
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/* extract facility and priority level */
|
|
|
|
if (flags & MARK)
|
|
|
|
fac = LOG_NFACILITIES;
|
|
|
|
else
|
|
|
|
fac = LOG_FAC(pri);
|
2005-03-28 10:59:19 +00:00
|
|
|
|
|
|
|
/* Check maximum facility number. */
|
|
|
|
if (fac > LOG_NFACILITIES) {
|
|
|
|
(void)sigsetmask(omask);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
prilev = LOG_PRI(pri);
|
|
|
|
|
1994-12-29 22:02:25 +00:00
|
|
|
/* extract program name */
|
2000-08-03 15:19:27 +00:00
|
|
|
for (i = 0; i < NAME_MAX; i++) {
|
2004-05-30 10:34:58 +00:00
|
|
|
if (!isprint(msg[i]) || msg[i] == ':' || msg[i] == '[' ||
|
2004-12-28 21:58:54 +00:00
|
|
|
msg[i] == '/' || isspace(msg[i]))
|
1994-12-29 22:02:25 +00:00
|
|
|
break;
|
|
|
|
prog[i] = msg[i];
|
|
|
|
}
|
|
|
|
prog[i] = 0;
|
|
|
|
|
1998-06-24 23:50:20 +00:00
|
|
|
/* add kernel prefix for kernel messages */
|
|
|
|
if (flags & ISKERNEL) {
|
2001-11-27 20:02:18 +00:00
|
|
|
snprintf(buf, sizeof(buf), "%s: %s",
|
|
|
|
use_bootfile ? bootfile : "kernel", msg);
|
1998-06-24 23:50:20 +00:00
|
|
|
msg = buf;
|
|
|
|
msglen = strlen(buf);
|
|
|
|
}
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/* log the message to the particular outputs */
|
|
|
|
if (!Initialized) {
|
|
|
|
f = &consfile;
|
|
|
|
f->f_file = open(ctty, O_WRONLY, 0);
|
|
|
|
|
|
|
|
if (f->f_file >= 0) {
|
2003-05-17 20:07:54 +00:00
|
|
|
(void)strlcpy(f->f_lasttime, timestamp,
|
|
|
|
sizeof(f->f_lasttime));
|
1994-05-26 05:23:31 +00:00
|
|
|
fprintlog(f, flags, msg);
|
|
|
|
(void)close(f->f_file);
|
|
|
|
}
|
|
|
|
(void)sigsetmask(omask);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (f = Files; f; f = f->f_next) {
|
|
|
|
/* skip messages that are incorrect priority */
|
1998-07-22 06:15:19 +00:00
|
|
|
if (!(((f->f_pcmp[fac] & PRI_EQ) && (f->f_pmask[fac] == prilev))
|
|
|
|
||((f->f_pcmp[fac] & PRI_LT) && (f->f_pmask[fac] < prilev))
|
|
|
|
||((f->f_pcmp[fac] & PRI_GT) && (f->f_pmask[fac] > prilev))
|
|
|
|
)
|
|
|
|
|| f->f_pmask[fac] == INTERNAL_NOPRI)
|
1994-05-26 05:23:31 +00:00
|
|
|
continue;
|
2002-11-07 19:53:29 +00:00
|
|
|
|
2000-07-24 14:10:17 +00:00
|
|
|
/* skip messages with the incorrect hostname */
|
2003-05-04 22:05:40 +00:00
|
|
|
if (skip_message(from, f->f_host, 0))
|
2002-11-07 19:53:29 +00:00
|
|
|
continue;
|
2000-07-24 14:10:17 +00:00
|
|
|
|
1994-12-29 22:02:25 +00:00
|
|
|
/* skip messages with the incorrect program name */
|
2003-05-04 22:05:40 +00:00
|
|
|
if (skip_message(prog, f->f_program, 1))
|
2002-11-07 19:53:29 +00:00
|
|
|
continue;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2002-11-07 19:53:29 +00:00
|
|
|
/* skip message to console if it has already been printed */
|
1994-05-26 05:23:31 +00:00
|
|
|
if (f->f_type == F_CONSOLE && (flags & IGN_CONS))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* don't output marks to recently written files */
|
|
|
|
if ((flags & MARK) && (now - f->f_time) < MarkInterval / 2)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* suppress duplicate lines to this file
|
|
|
|
*/
|
2002-01-05 07:34:52 +00:00
|
|
|
if (no_compress - (f->f_type != F_PIPE) < 1 &&
|
|
|
|
(flags & MARK) == 0 && msglen == f->f_prevlen &&
|
1994-05-26 05:23:31 +00:00
|
|
|
!strcmp(msg, f->f_prevline) &&
|
1999-08-17 01:25:16 +00:00
|
|
|
!strcasecmp(from, f->f_prevhost)) {
|
2003-05-17 20:07:54 +00:00
|
|
|
(void)strlcpy(f->f_lasttime, timestamp,
|
|
|
|
sizeof(f->f_lasttime));
|
1994-05-26 05:23:31 +00:00
|
|
|
f->f_prevcount++;
|
|
|
|
dprintf("msg repeated %d times, %ld sec of %d\n",
|
1998-07-06 20:28:08 +00:00
|
|
|
f->f_prevcount, (long)(now - f->f_time),
|
1994-05-26 05:23:31 +00:00
|
|
|
repeatinterval[f->f_repeatcount]);
|
|
|
|
/*
|
|
|
|
* If domark would have logged this by now,
|
|
|
|
* flush it now (so we don't hold isolated messages),
|
|
|
|
* but back off so we'll flush less often
|
|
|
|
* in the future.
|
|
|
|
*/
|
|
|
|
if (now > REPEATTIME(f)) {
|
|
|
|
fprintlog(f, flags, (char *)NULL);
|
|
|
|
BACKOFF(f);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* new line, save it */
|
|
|
|
if (f->f_prevcount)
|
|
|
|
fprintlog(f, 0, (char *)NULL);
|
|
|
|
f->f_repeatcount = 0;
|
1996-07-22 16:35:50 +00:00
|
|
|
f->f_prevpri = pri;
|
2003-05-17 20:07:54 +00:00
|
|
|
(void)strlcpy(f->f_lasttime, timestamp,
|
|
|
|
sizeof(f->f_lasttime));
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(f->f_prevhost, from,
|
|
|
|
sizeof(f->f_prevhost));
|
1994-05-26 05:23:31 +00:00
|
|
|
if (msglen < MAXSVLINE) {
|
|
|
|
f->f_prevlen = msglen;
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(f->f_prevline, msg, sizeof(f->f_prevline));
|
1994-05-26 05:23:31 +00:00
|
|
|
fprintlog(f, flags, (char *)NULL);
|
|
|
|
} else {
|
|
|
|
f->f_prevline[0] = 0;
|
|
|
|
f->f_prevlen = 0;
|
|
|
|
fprintlog(f, flags, msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
(void)sigsetmask(omask);
|
|
|
|
}
|
|
|
|
|
2004-07-04 19:13:58 +00:00
|
|
|
static void
|
|
|
|
dofsync(void)
|
|
|
|
{
|
|
|
|
struct filed *f;
|
|
|
|
|
|
|
|
for (f = Files; f; f = f->f_next) {
|
|
|
|
if ((f->f_type == F_FILE) &&
|
|
|
|
(f->f_flags & FFLAG_NEEDSYNC)) {
|
|
|
|
f->f_flags &= ~FFLAG_NEEDSYNC;
|
|
|
|
(void)fsync(f->f_file);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
fprintlog(struct filed *f, int flags, const char *msg)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
1998-07-22 06:15:19 +00:00
|
|
|
struct iovec iov[7];
|
1994-05-26 05:23:31 +00:00
|
|
|
struct iovec *v;
|
2000-12-16 18:25:48 +00:00
|
|
|
struct addrinfo *r;
|
|
|
|
int i, l, lsent = 0;
|
2002-01-09 17:36:53 +00:00
|
|
|
char line[MAXLINE + 1], repbuf[80], greetings[200], *wmsg = NULL;
|
2004-05-26 21:14:13 +00:00
|
|
|
char nul[] = "", space[] = " ", lf[] = "\n", crlf[] = "\r\n";
|
2001-09-09 14:25:02 +00:00
|
|
|
const char *msgret;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
v = iov;
|
|
|
|
if (f->f_type == F_WALL) {
|
|
|
|
v->iov_base = greetings;
|
1997-09-19 22:22:04 +00:00
|
|
|
v->iov_len = snprintf(greetings, sizeof greetings,
|
1994-05-26 05:23:31 +00:00
|
|
|
"\r\n\7Message from syslogd@%s at %.24s ...\r\n",
|
|
|
|
f->f_prevhost, ctime(&now));
|
2001-08-20 13:24:39 +00:00
|
|
|
if (v->iov_len > 0)
|
|
|
|
v++;
|
2004-05-26 21:14:13 +00:00
|
|
|
v->iov_base = nul;
|
1994-05-26 05:23:31 +00:00
|
|
|
v->iov_len = 0;
|
|
|
|
v++;
|
|
|
|
} else {
|
|
|
|
v->iov_base = f->f_lasttime;
|
|
|
|
v->iov_len = 15;
|
|
|
|
v++;
|
2004-05-26 21:14:13 +00:00
|
|
|
v->iov_base = space;
|
1994-05-26 05:23:31 +00:00
|
|
|
v->iov_len = 1;
|
|
|
|
v++;
|
|
|
|
}
|
1998-07-22 06:15:19 +00:00
|
|
|
|
|
|
|
if (LogFacPri) {
|
|
|
|
static char fp_buf[30]; /* Hollow laugh */
|
|
|
|
int fac = f->f_prevpri & LOG_FACMASK;
|
|
|
|
int pri = LOG_PRI(f->f_prevpri);
|
2001-05-21 22:13:55 +00:00
|
|
|
const char *f_s = NULL;
|
1998-07-22 06:15:19 +00:00
|
|
|
char f_n[5]; /* Hollow laugh */
|
2001-05-21 22:13:55 +00:00
|
|
|
const char *p_s = NULL;
|
1998-07-22 06:15:19 +00:00
|
|
|
char p_n[5]; /* Hollow laugh */
|
|
|
|
|
|
|
|
if (LogFacPri > 1) {
|
|
|
|
CODE *c;
|
|
|
|
|
2000-01-13 12:59:58 +00:00
|
|
|
for (c = facilitynames; c->c_name; c++) {
|
1998-07-22 06:15:19 +00:00
|
|
|
if (c->c_val == fac) {
|
|
|
|
f_s = c->c_name;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2000-01-13 12:59:58 +00:00
|
|
|
for (c = prioritynames; c->c_name; c++) {
|
1998-07-22 06:15:19 +00:00
|
|
|
if (c->c_val == pri) {
|
|
|
|
p_s = c->c_name;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!f_s) {
|
|
|
|
snprintf(f_n, sizeof f_n, "%d", LOG_FAC(fac));
|
|
|
|
f_s = f_n;
|
|
|
|
}
|
|
|
|
if (!p_s) {
|
|
|
|
snprintf(p_n, sizeof p_n, "%d", pri);
|
|
|
|
p_s = p_n;
|
|
|
|
}
|
|
|
|
snprintf(fp_buf, sizeof fp_buf, "<%s.%s> ", f_s, p_s);
|
|
|
|
v->iov_base = fp_buf;
|
|
|
|
v->iov_len = strlen(fp_buf);
|
|
|
|
} else {
|
2004-11-11 09:41:03 +00:00
|
|
|
v->iov_base = nul;
|
1998-07-22 06:15:19 +00:00
|
|
|
v->iov_len = 0;
|
|
|
|
}
|
|
|
|
v++;
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
v->iov_base = f->f_prevhost;
|
|
|
|
v->iov_len = strlen(v->iov_base);
|
|
|
|
v++;
|
2004-05-26 21:14:13 +00:00
|
|
|
v->iov_base = space;
|
1994-05-26 05:23:31 +00:00
|
|
|
v->iov_len = 1;
|
|
|
|
v++;
|
|
|
|
|
|
|
|
if (msg) {
|
2001-09-09 14:25:02 +00:00
|
|
|
wmsg = strdup(msg); /* XXX iov_base needs a `const' sibling. */
|
2001-09-30 16:09:17 +00:00
|
|
|
if (wmsg == NULL) {
|
|
|
|
logerror("strdup");
|
|
|
|
exit(1);
|
|
|
|
}
|
2001-09-09 14:25:02 +00:00
|
|
|
v->iov_base = wmsg;
|
1994-05-26 05:23:31 +00:00
|
|
|
v->iov_len = strlen(msg);
|
|
|
|
} else if (f->f_prevcount > 1) {
|
|
|
|
v->iov_base = repbuf;
|
2001-09-01 07:57:35 +00:00
|
|
|
v->iov_len = snprintf(repbuf, sizeof repbuf,
|
|
|
|
"last message repeated %d times", f->f_prevcount);
|
1994-05-26 05:23:31 +00:00
|
|
|
} else {
|
|
|
|
v->iov_base = f->f_prevline;
|
|
|
|
v->iov_len = f->f_prevlen;
|
|
|
|
}
|
|
|
|
v++;
|
|
|
|
|
|
|
|
dprintf("Logging to %s", TypeNames[f->f_type]);
|
|
|
|
f->f_time = now;
|
|
|
|
|
|
|
|
switch (f->f_type) {
|
|
|
|
case F_UNUSED:
|
|
|
|
dprintf("\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case F_FORW:
|
|
|
|
dprintf(" %s\n", f->f_un.f_forw.f_hname);
|
1998-06-27 21:45:59 +00:00
|
|
|
/* check for local vs remote messages */
|
1999-08-17 01:25:16 +00:00
|
|
|
if (strcasecmp(f->f_prevhost, LocalHostName))
|
1998-06-27 21:45:59 +00:00
|
|
|
l = snprintf(line, sizeof line - 1,
|
|
|
|
"<%d>%.15s Forwarded from %s: %s",
|
2004-05-26 21:14:13 +00:00
|
|
|
f->f_prevpri, (char *)iov[0].iov_base,
|
|
|
|
f->f_prevhost, (char *)iov[5].iov_base);
|
1998-06-27 21:45:59 +00:00
|
|
|
else
|
|
|
|
l = snprintf(line, sizeof line - 1, "<%d>%.15s %s",
|
2004-05-26 21:14:13 +00:00
|
|
|
f->f_prevpri, (char *)iov[0].iov_base,
|
|
|
|
(char *)iov[5].iov_base);
|
2001-08-20 13:24:39 +00:00
|
|
|
if (l < 0)
|
|
|
|
l = 0;
|
|
|
|
else if (l > MAXLINE)
|
1994-05-26 05:23:31 +00:00
|
|
|
l = MAXLINE;
|
2000-12-16 18:25:48 +00:00
|
|
|
|
|
|
|
if (finet) {
|
|
|
|
for (r = f->f_un.f_forw.f_addr; r; r = r->ai_next) {
|
|
|
|
for (i = 0; i < *finet; i++) {
|
2004-11-11 09:41:03 +00:00
|
|
|
#if 0
|
2000-12-16 18:25:48 +00:00
|
|
|
/*
|
|
|
|
* should we check AF first, or just
|
|
|
|
* trial and error? FWD
|
|
|
|
*/
|
|
|
|
if (r->ai_family ==
|
2004-11-11 09:41:03 +00:00
|
|
|
address_family_of(finet[i+1]))
|
2000-12-16 18:25:48 +00:00
|
|
|
#endif
|
|
|
|
lsent = sendto(finet[i+1], line, l, 0,
|
|
|
|
r->ai_addr, r->ai_addrlen);
|
2004-11-11 09:41:03 +00:00
|
|
|
if (lsent == l)
|
2000-12-16 18:25:48 +00:00
|
|
|
break;
|
|
|
|
}
|
2004-11-11 09:41:03 +00:00
|
|
|
if (lsent == l && !send_to_all)
|
2000-12-16 18:25:48 +00:00
|
|
|
break;
|
|
|
|
}
|
2002-08-25 06:05:25 +00:00
|
|
|
dprintf("lsent/l: %d/%d\n", lsent, l);
|
2000-12-16 18:25:48 +00:00
|
|
|
if (lsent != l) {
|
|
|
|
int e = errno;
|
|
|
|
logerror("sendto");
|
2002-08-25 06:05:25 +00:00
|
|
|
errno = e;
|
|
|
|
switch (errno) {
|
2005-05-19 21:09:44 +00:00
|
|
|
case ENOBUFS:
|
|
|
|
case ENETDOWN:
|
2002-08-25 06:05:25 +00:00
|
|
|
case EHOSTUNREACH:
|
|
|
|
case EHOSTDOWN:
|
|
|
|
break;
|
|
|
|
/* case EBADF: */
|
|
|
|
/* case EACCES: */
|
|
|
|
/* case ENOTSOCK: */
|
|
|
|
/* case EFAULT: */
|
|
|
|
/* case EMSGSIZE: */
|
|
|
|
/* case EAGAIN: */
|
|
|
|
/* case ENOBUFS: */
|
|
|
|
/* case ECONNREFUSED: */
|
|
|
|
default:
|
2003-11-16 21:42:00 +00:00
|
|
|
dprintf("removing entry\n");
|
2002-08-25 06:05:25 +00:00
|
|
|
f->f_type = F_UNUSED;
|
|
|
|
break;
|
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case F_FILE:
|
|
|
|
dprintf(" %s\n", f->f_un.f_fname);
|
2004-05-26 21:14:13 +00:00
|
|
|
v->iov_base = lf;
|
1996-11-18 21:48:29 +00:00
|
|
|
v->iov_len = 1;
|
1998-07-22 06:15:19 +00:00
|
|
|
if (writev(f->f_file, iov, 7) < 0) {
|
2006-03-30 21:04:52 +00:00
|
|
|
/*
|
|
|
|
* If writev(2) fails for potentially transient errors
|
|
|
|
* like the * filesystem being full, ignore it.
|
|
|
|
* Otherwise remove * this logfile from the list.
|
|
|
|
*/
|
|
|
|
if (errno != ENOSPC) {
|
|
|
|
int e = errno;
|
|
|
|
(void)close(f->f_file);
|
|
|
|
f->f_type = F_UNUSED;
|
|
|
|
errno = e;
|
|
|
|
logerror(f->f_un.f_fname);
|
|
|
|
}
|
2004-07-04 19:13:58 +00:00
|
|
|
} else if ((flags & SYNC_FILE) && (f->f_flags & FFLAG_SYNC)) {
|
|
|
|
f->f_flags |= FFLAG_NEEDSYNC;
|
|
|
|
needdofsync = 1;
|
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
break;
|
|
|
|
|
1997-02-22 12:59:36 +00:00
|
|
|
case F_PIPE:
|
|
|
|
dprintf(" %s\n", f->f_un.f_pipe.f_pname);
|
2004-05-26 21:14:13 +00:00
|
|
|
v->iov_base = lf;
|
1997-02-22 12:59:36 +00:00
|
|
|
v->iov_len = 1;
|
|
|
|
if (f->f_un.f_pipe.f_pid == 0) {
|
|
|
|
if ((f->f_file = p_open(f->f_un.f_pipe.f_pname,
|
|
|
|
&f->f_un.f_pipe.f_pid)) < 0) {
|
|
|
|
f->f_type = F_UNUSED;
|
|
|
|
logerror(f->f_un.f_pipe.f_pname);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
1998-07-22 06:15:19 +00:00
|
|
|
if (writev(f->f_file, iov, 7) < 0) {
|
1997-02-22 12:59:36 +00:00
|
|
|
int e = errno;
|
|
|
|
(void)close(f->f_file);
|
|
|
|
if (f->f_un.f_pipe.f_pid > 0)
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
deadq_enter(f->f_un.f_pipe.f_pid,
|
|
|
|
f->f_un.f_pipe.f_pname);
|
1997-02-22 12:59:36 +00:00
|
|
|
f->f_un.f_pipe.f_pid = 0;
|
|
|
|
errno = e;
|
|
|
|
logerror(f->f_un.f_pipe.f_pname);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
1996-11-26 02:24:42 +00:00
|
|
|
case F_CONSOLE:
|
|
|
|
if (flags & IGN_CONS) {
|
|
|
|
dprintf(" (ignored)\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
1996-11-18 21:48:29 +00:00
|
|
|
case F_TTY:
|
1996-11-26 02:24:42 +00:00
|
|
|
dprintf(" %s%s\n", _PATH_DEV, f->f_un.f_fname);
|
2004-05-26 21:14:13 +00:00
|
|
|
v->iov_base = crlf;
|
1996-11-18 21:48:29 +00:00
|
|
|
v->iov_len = 2;
|
|
|
|
|
|
|
|
errno = 0; /* ttymsg() only sometimes returns an errno */
|
1998-07-22 06:15:19 +00:00
|
|
|
if ((msgret = ttymsg(iov, 7, f->f_un.f_fname, 10))) {
|
1996-11-18 21:48:29 +00:00
|
|
|
f->f_type = F_UNUSED;
|
|
|
|
logerror(msgret);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
case F_USERS:
|
|
|
|
case F_WALL:
|
|
|
|
dprintf("\n");
|
2004-05-26 21:14:13 +00:00
|
|
|
v->iov_base = crlf;
|
1994-05-26 05:23:31 +00:00
|
|
|
v->iov_len = 2;
|
|
|
|
wallmsg(f, iov);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
f->f_prevcount = 0;
|
2001-09-11 08:18:04 +00:00
|
|
|
if (msg)
|
|
|
|
free(wmsg);
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* WALLMSG -- Write a message to the world at large
|
|
|
|
*
|
|
|
|
* Write the specified message to either the entire
|
|
|
|
* world, or a list of approved users.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
wallmsg(struct filed *f, struct iovec *iov)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
|
|
|
static int reenter; /* avoid calling ourselves */
|
|
|
|
FILE *uf;
|
|
|
|
struct utmp ut;
|
|
|
|
int i;
|
2001-09-09 14:25:02 +00:00
|
|
|
const char *p;
|
1994-05-26 05:23:31 +00:00
|
|
|
char line[sizeof(ut.ut_line) + 1];
|
|
|
|
|
|
|
|
if (reenter++)
|
|
|
|
return;
|
|
|
|
if ((uf = fopen(_PATH_UTMP, "r")) == NULL) {
|
|
|
|
logerror(_PATH_UTMP);
|
|
|
|
reenter = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/* NOSTRICT */
|
|
|
|
while (fread((char *)&ut, sizeof(ut), 1, uf) == 1) {
|
|
|
|
if (ut.ut_name[0] == '\0')
|
|
|
|
continue;
|
2004-05-29 23:40:30 +00:00
|
|
|
/* We must use strncpy since ut_* may not be NUL terminated. */
|
|
|
|
strncpy(line, ut.ut_line, sizeof(line) - 1);
|
|
|
|
line[sizeof(line) - 1] = '\0';
|
1994-05-26 05:23:31 +00:00
|
|
|
if (f->f_type == F_WALL) {
|
1998-07-22 06:15:19 +00:00
|
|
|
if ((p = ttymsg(iov, 7, line, TTYMSGTIME)) != NULL) {
|
1994-05-26 05:23:31 +00:00
|
|
|
errno = 0; /* already in msg */
|
|
|
|
logerror(p);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* should we send the message to this user? */
|
|
|
|
for (i = 0; i < MAXUNAMES; i++) {
|
|
|
|
if (!f->f_un.f_uname[i][0])
|
|
|
|
break;
|
|
|
|
if (!strncmp(f->f_un.f_uname[i], ut.ut_name,
|
|
|
|
UT_NAMESIZE)) {
|
1998-07-22 06:15:19 +00:00
|
|
|
if ((p = ttymsg(iov, 7, line, TTYMSGTIME))
|
1996-07-22 16:35:50 +00:00
|
|
|
!= NULL) {
|
1994-05-26 05:23:31 +00:00
|
|
|
errno = 0; /* already in msg */
|
|
|
|
logerror(p);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
(void)fclose(uf);
|
|
|
|
reenter = 0;
|
|
|
|
}
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
reapchild(int signo __unused)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
int status;
|
1997-02-22 12:59:36 +00:00
|
|
|
pid_t pid;
|
|
|
|
struct filed *f;
|
|
|
|
|
|
|
|
while ((pid = wait3(&status, WNOHANG, (struct rusage *)NULL)) > 0) {
|
|
|
|
if (!Initialized)
|
|
|
|
/* Don't tell while we are initting. */
|
|
|
|
continue;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
1997-02-22 12:59:36 +00:00
|
|
|
/* First, look if it's a process from the dead queue. */
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
if (deadq_remove(pid))
|
|
|
|
goto oncemore;
|
1997-02-22 12:59:36 +00:00
|
|
|
|
|
|
|
/* Now, look in list of active processes. */
|
|
|
|
for (f = Files; f; f = f->f_next)
|
|
|
|
if (f->f_type == F_PIPE &&
|
|
|
|
f->f_un.f_pipe.f_pid == pid) {
|
|
|
|
(void)close(f->f_file);
|
|
|
|
f->f_un.f_pipe.f_pid = 0;
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
log_deadchild(pid, status,
|
|
|
|
f->f_un.f_pipe.f_pname);
|
1997-02-22 12:59:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
oncemore:
|
2000-01-14 15:09:06 +00:00
|
|
|
continue;
|
1997-02-22 12:59:36 +00:00
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return a printable representation of a host address.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static const char *
|
|
|
|
cvthname(struct sockaddr *f)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
2003-05-04 22:05:40 +00:00
|
|
|
int error, hl;
|
1998-12-28 00:39:14 +00:00
|
|
|
sigset_t omask, nmask;
|
2000-12-16 18:25:48 +00:00
|
|
|
static char hname[NI_MAXHOST], ip[NI_MAXHOST];
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2000-12-16 18:25:48 +00:00
|
|
|
error = getnameinfo((struct sockaddr *)f,
|
|
|
|
((struct sockaddr *)f)->sa_len,
|
2005-05-13 16:31:11 +00:00
|
|
|
ip, sizeof ip, NULL, 0, NI_NUMERICHOST);
|
2000-12-16 18:25:48 +00:00
|
|
|
dprintf("cvthname(%s)\n", ip);
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2000-12-16 18:25:48 +00:00
|
|
|
if (error) {
|
|
|
|
dprintf("Malformed from address %s\n", gai_strerror(error));
|
1994-05-26 05:23:31 +00:00
|
|
|
return ("???");
|
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
if (!resolve)
|
|
|
|
return (ip);
|
|
|
|
|
1998-12-28 00:39:14 +00:00
|
|
|
sigemptyset(&nmask);
|
|
|
|
sigaddset(&nmask, SIGHUP);
|
|
|
|
sigprocmask(SIG_BLOCK, &nmask, &omask);
|
2000-12-16 18:25:48 +00:00
|
|
|
error = getnameinfo((struct sockaddr *)f,
|
|
|
|
((struct sockaddr *)f)->sa_len,
|
2005-05-13 16:31:11 +00:00
|
|
|
hname, sizeof hname, NULL, 0, NI_NAMEREQD);
|
1998-12-28 00:39:14 +00:00
|
|
|
sigprocmask(SIG_SETMASK, &omask, NULL);
|
2000-12-16 18:25:48 +00:00
|
|
|
if (error) {
|
|
|
|
dprintf("Host name for your address (%s) unknown\n", ip);
|
|
|
|
return (ip);
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
2003-05-04 22:05:40 +00:00
|
|
|
hl = strlen(hname);
|
|
|
|
if (hl > 0 && hname[hl-1] == '.')
|
|
|
|
hname[--hl] = '\0';
|
2003-05-17 20:05:18 +00:00
|
|
|
trimdomain(hname, hl);
|
2000-12-16 18:25:48 +00:00
|
|
|
return (hname);
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
dodie(int signo)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
1997-02-22 12:59:36 +00:00
|
|
|
|
2001-09-01 07:57:35 +00:00
|
|
|
WantDie = signo;
|
|
|
|
}
|
1997-02-22 12:59:36 +00:00
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
domark(int signo __unused)
|
2001-09-01 07:57:35 +00:00
|
|
|
{
|
1997-02-22 12:59:36 +00:00
|
|
|
|
2001-09-01 07:57:35 +00:00
|
|
|
MarkSet = 1;
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print syslogd errors some place.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
logerror(const char *type)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
1997-02-22 12:59:36 +00:00
|
|
|
char buf[512];
|
2003-11-16 21:51:06 +00:00
|
|
|
static int recursed = 0;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
2003-11-16 21:51:06 +00:00
|
|
|
/* If there's an error while trying to log an error, give up. */
|
|
|
|
if (recursed)
|
|
|
|
return;
|
|
|
|
recursed++;
|
1994-05-26 05:23:31 +00:00
|
|
|
if (errno)
|
|
|
|
(void)snprintf(buf,
|
1997-09-19 22:22:04 +00:00
|
|
|
sizeof buf, "syslogd: %s: %s", type, strerror(errno));
|
1994-05-26 05:23:31 +00:00
|
|
|
else
|
1997-09-19 22:22:04 +00:00
|
|
|
(void)snprintf(buf, sizeof buf, "syslogd: %s", type);
|
1994-05-26 05:23:31 +00:00
|
|
|
errno = 0;
|
|
|
|
dprintf("%s\n", buf);
|
|
|
|
logmsg(LOG_SYSLOG|LOG_ERR, buf, LocalHostName, ADDDATE);
|
2003-11-16 21:51:06 +00:00
|
|
|
recursed--;
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
die(int signo)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
|
|
|
struct filed *f;
|
2004-11-04 22:20:21 +00:00
|
|
|
struct funix *fx;
|
1997-03-14 01:27:02 +00:00
|
|
|
int was_initialized;
|
1994-05-26 05:23:31 +00:00
|
|
|
char buf[100];
|
|
|
|
|
1997-03-14 01:27:02 +00:00
|
|
|
was_initialized = Initialized;
|
1997-02-22 12:59:36 +00:00
|
|
|
Initialized = 0; /* Don't log SIGCHLDs. */
|
1994-05-26 05:23:31 +00:00
|
|
|
for (f = Files; f != NULL; f = f->f_next) {
|
|
|
|
/* flush any pending output */
|
|
|
|
if (f->f_prevcount)
|
|
|
|
fprintlog(f, 0, (char *)NULL);
|
2004-05-30 00:02:19 +00:00
|
|
|
if (f->f_type == F_PIPE && f->f_un.f_pipe.f_pid > 0) {
|
1997-02-22 12:59:36 +00:00
|
|
|
(void)close(f->f_file);
|
2004-05-30 00:02:19 +00:00
|
|
|
f->f_un.f_pipe.f_pid = 0;
|
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
1997-03-14 01:27:02 +00:00
|
|
|
Initialized = was_initialized;
|
1994-05-26 05:23:31 +00:00
|
|
|
if (signo) {
|
|
|
|
dprintf("syslogd: exiting on signal %d\n", signo);
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)snprintf(buf, sizeof(buf), "exiting on signal %d", signo);
|
1994-05-26 05:23:31 +00:00
|
|
|
errno = 0;
|
|
|
|
logerror(buf);
|
|
|
|
}
|
2004-11-04 22:20:21 +00:00
|
|
|
STAILQ_FOREACH(fx, &funixes, next)
|
|
|
|
(void)unlink(fx->name);
|
2005-08-24 17:26:26 +00:00
|
|
|
pidfile_remove(pfh);
|
2004-11-04 22:20:21 +00:00
|
|
|
|
1996-11-18 21:48:29 +00:00
|
|
|
exit(1);
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* INIT -- Initialize syslogd from configuration table
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
init(int signo)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
FILE *cf;
|
|
|
|
struct filed *f, *next, **nextp;
|
|
|
|
char *p;
|
|
|
|
char cline[LINE_MAX];
|
1994-12-29 22:02:25 +00:00
|
|
|
char prog[NAME_MAX+1];
|
2001-03-09 21:24:13 +00:00
|
|
|
char host[MAXHOSTNAMELEN];
|
2001-08-27 21:37:15 +00:00
|
|
|
char oldLocalHostName[MAXHOSTNAMELEN];
|
|
|
|
char hostMsg[2*MAXHOSTNAMELEN+40];
|
2001-11-27 20:02:18 +00:00
|
|
|
char bootfileMsg[LINE_MAX];
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
dprintf("init\n");
|
|
|
|
|
2001-08-27 21:37:15 +00:00
|
|
|
/*
|
|
|
|
* Load hostname (may have changed).
|
|
|
|
*/
|
|
|
|
if (signo != 0)
|
|
|
|
(void)strlcpy(oldLocalHostName, LocalHostName,
|
|
|
|
sizeof(oldLocalHostName));
|
|
|
|
if (gethostname(LocalHostName, sizeof(LocalHostName)))
|
|
|
|
err(EX_OSERR, "gethostname() failed");
|
|
|
|
if ((p = strchr(LocalHostName, '.')) != NULL) {
|
|
|
|
*p++ = '\0';
|
|
|
|
LocalDomain = p;
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
2001-08-27 21:37:15 +00:00
|
|
|
LocalDomain = "";
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
2001-08-27 21:37:15 +00:00
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/*
|
|
|
|
* Close all open log files.
|
|
|
|
*/
|
|
|
|
Initialized = 0;
|
|
|
|
for (f = Files; f != NULL; f = next) {
|
|
|
|
/* flush any pending output */
|
|
|
|
if (f->f_prevcount)
|
|
|
|
fprintlog(f, 0, (char *)NULL);
|
|
|
|
|
|
|
|
switch (f->f_type) {
|
|
|
|
case F_FILE:
|
|
|
|
case F_FORW:
|
1996-11-26 02:24:42 +00:00
|
|
|
case F_CONSOLE:
|
|
|
|
case F_TTY:
|
1996-12-10 17:52:23 +00:00
|
|
|
(void)close(f->f_file);
|
1996-11-26 02:24:42 +00:00
|
|
|
break;
|
1997-02-22 12:59:36 +00:00
|
|
|
case F_PIPE:
|
2004-05-30 00:02:19 +00:00
|
|
|
if (f->f_un.f_pipe.f_pid > 0) {
|
|
|
|
(void)close(f->f_file);
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
deadq_enter(f->f_un.f_pipe.f_pid,
|
|
|
|
f->f_un.f_pipe.f_pname);
|
2004-05-30 00:02:19 +00:00
|
|
|
}
|
1997-02-22 12:59:36 +00:00
|
|
|
f->f_un.f_pipe.f_pid = 0;
|
|
|
|
break;
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
next = f->f_next;
|
2000-08-03 15:19:27 +00:00
|
|
|
if (f->f_program) free(f->f_program);
|
2000-07-24 14:10:17 +00:00
|
|
|
if (f->f_host) free(f->f_host);
|
1994-05-26 05:23:31 +00:00
|
|
|
free((char *)f);
|
|
|
|
}
|
|
|
|
Files = NULL;
|
|
|
|
nextp = &Files;
|
|
|
|
|
|
|
|
/* open the configuration file */
|
|
|
|
if ((cf = fopen(ConfFile, "r")) == NULL) {
|
|
|
|
dprintf("cannot open %s\n", ConfFile);
|
|
|
|
*nextp = (struct filed *)calloc(1, sizeof(*f));
|
2001-09-30 16:09:17 +00:00
|
|
|
if (*nextp == NULL) {
|
|
|
|
logerror("calloc");
|
|
|
|
exit(1);
|
|
|
|
}
|
2000-07-24 14:10:17 +00:00
|
|
|
cfline("*.ERR\t/dev/console", *nextp, "*", "*");
|
1994-05-26 05:23:31 +00:00
|
|
|
(*nextp)->f_next = (struct filed *)calloc(1, sizeof(*f));
|
2001-09-30 16:09:17 +00:00
|
|
|
if ((*nextp)->f_next == NULL) {
|
|
|
|
logerror("calloc");
|
|
|
|
exit(1);
|
|
|
|
}
|
2000-07-24 14:10:17 +00:00
|
|
|
cfline("*.PANIC\t*", (*nextp)->f_next, "*", "*");
|
1994-05-26 05:23:31 +00:00
|
|
|
Initialized = 1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Foreach line in the conf table, open that file.
|
|
|
|
*/
|
|
|
|
f = NULL;
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(host, "*", sizeof(host));
|
|
|
|
(void)strlcpy(prog, "*", sizeof(prog));
|
1994-05-26 05:23:31 +00:00
|
|
|
while (fgets(cline, sizeof(cline), cf) != NULL) {
|
|
|
|
/*
|
|
|
|
* check for end-of-section, comments, strip off trailing
|
1994-12-29 22:02:25 +00:00
|
|
|
* spaces and newline character. #!prog is treated specially:
|
|
|
|
* following lines apply only to that program.
|
1994-05-26 05:23:31 +00:00
|
|
|
*/
|
|
|
|
for (p = cline; isspace(*p); ++p)
|
|
|
|
continue;
|
1994-12-29 22:02:25 +00:00
|
|
|
if (*p == 0)
|
|
|
|
continue;
|
2000-08-03 15:19:27 +00:00
|
|
|
if (*p == '#') {
|
1994-12-29 22:02:25 +00:00
|
|
|
p++;
|
2000-07-24 14:10:17 +00:00
|
|
|
if (*p != '!' && *p != '+' && *p != '-')
|
1994-12-29 22:02:25 +00:00
|
|
|
continue;
|
|
|
|
}
|
2000-07-24 14:10:17 +00:00
|
|
|
if (*p == '+' || *p == '-') {
|
2001-09-13 06:48:41 +00:00
|
|
|
host[0] = *p++;
|
2001-09-13 05:09:14 +00:00
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
2000-07-24 14:10:17 +00:00
|
|
|
if ((!*p) || (*p == '*')) {
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(host, "*", sizeof(host));
|
2000-07-24 14:10:17 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (*p == '@')
|
|
|
|
p = LocalHostName;
|
2001-03-09 21:24:13 +00:00
|
|
|
for (i = 1; i < MAXHOSTNAMELEN - 1; i++) {
|
2003-02-21 19:02:31 +00:00
|
|
|
if (!isalnum(*p) && *p != '.' && *p != '-'
|
2004-12-28 22:25:04 +00:00
|
|
|
&& *p != ',' && *p != ':' && *p != '%')
|
2000-07-24 14:10:17 +00:00
|
|
|
break;
|
|
|
|
host[i] = *p++;
|
|
|
|
}
|
|
|
|
host[i] = '\0';
|
|
|
|
continue;
|
|
|
|
}
|
2000-08-03 15:19:27 +00:00
|
|
|
if (*p == '!') {
|
1994-12-29 22:02:25 +00:00
|
|
|
p++;
|
2000-08-03 15:19:27 +00:00
|
|
|
while (isspace(*p)) p++;
|
|
|
|
if ((!*p) || (*p == '*')) {
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(prog, "*", sizeof(prog));
|
1994-12-29 22:02:25 +00:00
|
|
|
continue;
|
|
|
|
}
|
2000-08-03 15:19:27 +00:00
|
|
|
for (i = 0; i < NAME_MAX; i++) {
|
2004-12-28 21:58:54 +00:00
|
|
|
if (!isprint(p[i]) || isspace(p[i]))
|
1994-12-29 22:02:25 +00:00
|
|
|
break;
|
|
|
|
prog[i] = p[i];
|
|
|
|
}
|
|
|
|
prog[i] = 0;
|
1994-05-26 05:23:31 +00:00
|
|
|
continue;
|
1994-12-29 22:02:25 +00:00
|
|
|
}
|
2004-05-29 23:40:30 +00:00
|
|
|
for (i = strlen(cline) - 1; i >= 0 && isspace(cline[i]); i--)
|
|
|
|
cline[i] = '\0';
|
1994-05-26 05:23:31 +00:00
|
|
|
f = (struct filed *)calloc(1, sizeof(*f));
|
2001-09-30 16:09:17 +00:00
|
|
|
if (f == NULL) {
|
|
|
|
logerror("calloc");
|
|
|
|
exit(1);
|
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
*nextp = f;
|
|
|
|
nextp = &f->f_next;
|
2000-07-24 14:10:17 +00:00
|
|
|
cfline(cline, f, prog, host);
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* close the configuration file */
|
|
|
|
(void)fclose(cf);
|
|
|
|
|
|
|
|
Initialized = 1;
|
|
|
|
|
|
|
|
if (Debug) {
|
|
|
|
for (f = Files; f; f = f->f_next) {
|
|
|
|
for (i = 0; i <= LOG_NFACILITIES; i++)
|
|
|
|
if (f->f_pmask[i] == INTERNAL_NOPRI)
|
|
|
|
printf("X ");
|
|
|
|
else
|
|
|
|
printf("%d ", f->f_pmask[i]);
|
|
|
|
printf("%s: ", TypeNames[f->f_type]);
|
|
|
|
switch (f->f_type) {
|
|
|
|
case F_FILE:
|
|
|
|
printf("%s", f->f_un.f_fname);
|
|
|
|
break;
|
|
|
|
|
1996-11-26 02:24:42 +00:00
|
|
|
case F_CONSOLE:
|
|
|
|
case F_TTY:
|
|
|
|
printf("%s%s", _PATH_DEV, f->f_un.f_fname);
|
|
|
|
break;
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
case F_FORW:
|
|
|
|
printf("%s", f->f_un.f_forw.f_hname);
|
|
|
|
break;
|
|
|
|
|
1997-02-22 12:59:36 +00:00
|
|
|
case F_PIPE:
|
|
|
|
printf("%s", f->f_un.f_pipe.f_pname);
|
|
|
|
break;
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
case F_USERS:
|
|
|
|
for (i = 0; i < MAXUNAMES && *f->f_un.f_uname[i]; i++)
|
|
|
|
printf("%s, ", f->f_un.f_uname[i]);
|
|
|
|
break;
|
|
|
|
}
|
2000-08-03 15:19:27 +00:00
|
|
|
if (f->f_program)
|
1994-12-29 22:02:25 +00:00
|
|
|
printf(" (%s)", f->f_program);
|
1994-05-26 05:23:31 +00:00
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
logmsg(LOG_SYSLOG|LOG_INFO, "syslogd: restart", LocalHostName, ADDDATE);
|
|
|
|
dprintf("syslogd: restarted\n");
|
2001-08-27 21:37:15 +00:00
|
|
|
/*
|
|
|
|
* Log a change in hostname, but only on a restart.
|
|
|
|
*/
|
|
|
|
if (signo != 0 && strcmp(oldLocalHostName, LocalHostName) != 0) {
|
|
|
|
(void)snprintf(hostMsg, sizeof(hostMsg),
|
|
|
|
"syslogd: hostname changed, \"%s\" to \"%s\"",
|
|
|
|
oldLocalHostName, LocalHostName);
|
|
|
|
logmsg(LOG_SYSLOG|LOG_INFO, hostMsg, LocalHostName, ADDDATE);
|
|
|
|
dprintf("%s\n", hostMsg);
|
|
|
|
}
|
2001-11-27 20:02:18 +00:00
|
|
|
/*
|
|
|
|
* Log the kernel boot file if we aren't going to use it as
|
|
|
|
* the prefix, and if this is *not* a restart.
|
|
|
|
*/
|
|
|
|
if (signo == 0 && !use_bootfile) {
|
|
|
|
(void)snprintf(bootfileMsg, sizeof(bootfileMsg),
|
|
|
|
"syslogd: kernel boot file is %s", bootfile);
|
|
|
|
logmsg(LOG_KERN|LOG_INFO, bootfileMsg, LocalHostName, ADDDATE);
|
|
|
|
dprintf("%s\n", bootfileMsg);
|
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Crack a configuration file line
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
cfline(const char *line, struct filed *f, const char *prog, const char *host)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
2000-12-16 18:25:48 +00:00
|
|
|
struct addrinfo hints, *res;
|
2004-05-30 10:04:03 +00:00
|
|
|
int error, i, pri, syncfile;
|
2001-09-09 14:25:02 +00:00
|
|
|
const char *p, *q;
|
|
|
|
char *bp;
|
1994-05-26 05:23:31 +00:00
|
|
|
char buf[MAXLINE], ebuf[100];
|
|
|
|
|
2000-07-24 14:10:17 +00:00
|
|
|
dprintf("cfline(\"%s\", f, \"%s\", \"%s\")\n", line, prog, host);
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
errno = 0; /* keep strerror() stuff out of logerror messages */
|
|
|
|
|
|
|
|
/* clear out file entry */
|
|
|
|
memset(f, 0, sizeof(*f));
|
|
|
|
for (i = 0; i <= LOG_NFACILITIES; i++)
|
|
|
|
f->f_pmask[i] = INTERNAL_NOPRI;
|
|
|
|
|
2000-07-24 14:10:17 +00:00
|
|
|
/* save hostname if any */
|
2000-08-03 15:19:27 +00:00
|
|
|
if (host && *host == '*')
|
|
|
|
host = NULL;
|
2001-09-13 06:48:41 +00:00
|
|
|
if (host) {
|
2003-05-04 22:05:40 +00:00
|
|
|
int hl;
|
2001-09-13 06:48:41 +00:00
|
|
|
|
2000-08-03 15:12:06 +00:00
|
|
|
f->f_host = strdup(host);
|
2001-09-30 16:09:17 +00:00
|
|
|
if (f->f_host == NULL) {
|
|
|
|
logerror("strdup");
|
|
|
|
exit(1);
|
|
|
|
}
|
2001-09-13 06:48:41 +00:00
|
|
|
hl = strlen(f->f_host);
|
2003-05-04 22:05:40 +00:00
|
|
|
if (hl > 0 && f->f_host[hl-1] == '.')
|
2001-09-13 06:48:41 +00:00
|
|
|
f->f_host[--hl] = '\0';
|
2003-05-17 20:05:18 +00:00
|
|
|
trimdomain(f->f_host, hl);
|
2001-09-13 06:48:41 +00:00
|
|
|
}
|
2000-07-24 14:10:17 +00:00
|
|
|
|
1994-12-29 22:02:25 +00:00
|
|
|
/* save program name if any */
|
2000-08-03 15:19:27 +00:00
|
|
|
if (prog && *prog == '*')
|
|
|
|
prog = NULL;
|
2001-09-30 16:09:17 +00:00
|
|
|
if (prog) {
|
2000-08-03 15:19:27 +00:00
|
|
|
f->f_program = strdup(prog);
|
2001-09-30 16:09:17 +00:00
|
|
|
if (f->f_program == NULL) {
|
|
|
|
logerror("strdup");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
1994-12-29 22:02:25 +00:00
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/* scan through the list of selectors */
|
1998-12-04 06:49:20 +00:00
|
|
|
for (p = line; *p && *p != '\t' && *p != ' ';) {
|
1998-07-22 06:15:19 +00:00
|
|
|
int pri_done;
|
|
|
|
int pri_cmp;
|
2002-09-04 21:11:25 +00:00
|
|
|
int pri_invert;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
/* find the end of this facility name list */
|
1998-12-04 06:49:20 +00:00
|
|
|
for (q = p; *q && *q != '\t' && *q != ' ' && *q++ != '.'; )
|
1994-05-26 05:23:31 +00:00
|
|
|
continue;
|
|
|
|
|
1998-07-22 06:15:19 +00:00
|
|
|
/* get the priority comparison */
|
|
|
|
pri_cmp = 0;
|
|
|
|
pri_done = 0;
|
2002-09-04 21:11:25 +00:00
|
|
|
pri_invert = 0;
|
|
|
|
if (*q == '!') {
|
|
|
|
pri_invert = 1;
|
|
|
|
q++;
|
|
|
|
}
|
1998-07-22 06:15:19 +00:00
|
|
|
while (!pri_done) {
|
|
|
|
switch (*q) {
|
|
|
|
case '<':
|
|
|
|
pri_cmp |= PRI_LT;
|
|
|
|
q++;
|
|
|
|
break;
|
|
|
|
case '=':
|
|
|
|
pri_cmp |= PRI_EQ;
|
|
|
|
q++;
|
|
|
|
break;
|
|
|
|
case '>':
|
|
|
|
pri_cmp |= PRI_GT;
|
|
|
|
q++;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pri_done++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
/* collect priority name */
|
1998-12-04 06:49:20 +00:00
|
|
|
for (bp = buf; *q && !strchr("\t,; ", *q); )
|
1994-05-26 05:23:31 +00:00
|
|
|
*bp++ = *q++;
|
|
|
|
*bp = '\0';
|
|
|
|
|
|
|
|
/* skip cruft */
|
1998-12-04 06:49:20 +00:00
|
|
|
while (strchr(",;", *q))
|
1994-05-26 05:23:31 +00:00
|
|
|
q++;
|
|
|
|
|
|
|
|
/* decode priority name */
|
2002-03-24 06:02:10 +00:00
|
|
|
if (*buf == '*') {
|
1994-05-26 05:23:31 +00:00
|
|
|
pri = LOG_PRIMASK + 1;
|
2002-09-04 21:11:25 +00:00
|
|
|
pri_cmp = PRI_LT | PRI_EQ | PRI_GT;
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
2004-05-29 23:40:30 +00:00
|
|
|
/* Ignore trailing spaces. */
|
|
|
|
for (i = strlen(buf) - 1; i >= 0 && buf[i] == ' '; i--)
|
|
|
|
buf[i] = '\0';
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
pri = decode(buf, prioritynames);
|
|
|
|
if (pri < 0) {
|
1997-09-19 22:22:04 +00:00
|
|
|
(void)snprintf(ebuf, sizeof ebuf,
|
1994-05-26 05:23:31 +00:00
|
|
|
"unknown priority name \"%s\"", buf);
|
|
|
|
logerror(ebuf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2002-09-04 21:11:25 +00:00
|
|
|
if (!pri_cmp)
|
|
|
|
pri_cmp = (UniquePriority)
|
|
|
|
? (PRI_EQ)
|
|
|
|
: (PRI_EQ | PRI_GT)
|
|
|
|
;
|
|
|
|
if (pri_invert)
|
|
|
|
pri_cmp ^= PRI_LT | PRI_EQ | PRI_GT;
|
1994-05-26 05:23:31 +00:00
|
|
|
|
|
|
|
/* scan facilities */
|
1998-12-04 06:49:20 +00:00
|
|
|
while (*p && !strchr("\t.; ", *p)) {
|
|
|
|
for (bp = buf; *p && !strchr("\t,;. ", *p); )
|
1994-05-26 05:23:31 +00:00
|
|
|
*bp++ = *p++;
|
|
|
|
*bp = '\0';
|
1998-07-22 06:15:19 +00:00
|
|
|
|
2002-03-24 06:02:10 +00:00
|
|
|
if (*buf == '*') {
|
1998-07-22 06:15:19 +00:00
|
|
|
for (i = 0; i < LOG_NFACILITIES; i++) {
|
1994-05-26 05:23:31 +00:00
|
|
|
f->f_pmask[i] = pri;
|
1998-07-22 06:15:19 +00:00
|
|
|
f->f_pcmp[i] = pri_cmp;
|
|
|
|
}
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
1994-05-26 05:23:31 +00:00
|
|
|
i = decode(buf, facilitynames);
|
|
|
|
if (i < 0) {
|
1997-09-19 22:22:04 +00:00
|
|
|
(void)snprintf(ebuf, sizeof ebuf,
|
1994-05-26 05:23:31 +00:00
|
|
|
"unknown facility name \"%s\"",
|
|
|
|
buf);
|
|
|
|
logerror(ebuf);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
f->f_pmask[i >> 3] = pri;
|
1998-07-22 06:15:19 +00:00
|
|
|
f->f_pcmp[i >> 3] = pri_cmp;
|
1994-05-26 05:23:31 +00:00
|
|
|
}
|
|
|
|
while (*p == ',' || *p == ' ')
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
p = q;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* skip to action part */
|
1998-12-04 06:49:20 +00:00
|
|
|
while (*p == '\t' || *p == ' ')
|
1994-05-26 05:23:31 +00:00
|
|
|
p++;
|
|
|
|
|
2004-05-30 10:04:03 +00:00
|
|
|
if (*p == '-') {
|
|
|
|
syncfile = 0;
|
|
|
|
p++;
|
|
|
|
} else
|
|
|
|
syncfile = 1;
|
|
|
|
|
2002-03-24 05:52:04 +00:00
|
|
|
switch (*p) {
|
1994-05-26 05:23:31 +00:00
|
|
|
case '@':
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(f->f_un.f_forw.f_hname, ++p,
|
|
|
|
sizeof(f->f_un.f_forw.f_hname));
|
2000-12-16 18:25:48 +00:00
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_family = family;
|
|
|
|
hints.ai_socktype = SOCK_DGRAM;
|
|
|
|
error = getaddrinfo(f->f_un.f_forw.f_hname, "syslog", &hints,
|
|
|
|
&res);
|
|
|
|
if (error) {
|
|
|
|
logerror(gai_strerror(error));
|
1994-05-26 05:23:31 +00:00
|
|
|
break;
|
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
f->f_un.f_forw.f_addr = res;
|
1994-05-26 05:23:31 +00:00
|
|
|
f->f_type = F_FORW;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '/':
|
2006-03-06 10:36:33 +00:00
|
|
|
if ((f->f_file = open(p, logflags, 0600)) < 0) {
|
1996-12-10 17:52:23 +00:00
|
|
|
f->f_type = F_UNUSED;
|
1994-05-26 05:23:31 +00:00
|
|
|
logerror(p);
|
|
|
|
break;
|
|
|
|
}
|
2004-05-30 10:04:03 +00:00
|
|
|
if (syncfile)
|
|
|
|
f->f_flags |= FFLAG_SYNC;
|
1996-11-26 02:24:42 +00:00
|
|
|
if (isatty(f->f_file)) {
|
|
|
|
if (strcmp(p, ctty) == 0)
|
|
|
|
f->f_type = F_CONSOLE;
|
|
|
|
else
|
|
|
|
f->f_type = F_TTY;
|
2001-09-05 05:20:31 +00:00
|
|
|
(void)strlcpy(f->f_un.f_fname, p + sizeof(_PATH_DEV) - 1,
|
2001-09-01 07:57:35 +00:00
|
|
|
sizeof(f->f_un.f_fname));
|
1996-11-26 02:24:42 +00:00
|
|
|
} else {
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(f->f_un.f_fname, p, sizeof(f->f_un.f_fname));
|
1994-05-26 05:23:31 +00:00
|
|
|
f->f_type = F_FILE;
|
1996-11-26 02:24:42 +00:00
|
|
|
}
|
1994-05-26 05:23:31 +00:00
|
|
|
break;
|
|
|
|
|
1997-02-22 12:59:36 +00:00
|
|
|
case '|':
|
|
|
|
f->f_un.f_pipe.f_pid = 0;
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(f->f_un.f_fname, p + 1, sizeof(f->f_un.f_fname));
|
1997-02-22 12:59:36 +00:00
|
|
|
f->f_type = F_PIPE;
|
|
|
|
break;
|
|
|
|
|
1994-05-26 05:23:31 +00:00
|
|
|
case '*':
|
|
|
|
f->f_type = F_WALL;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
for (i = 0; i < MAXUNAMES && *p; i++) {
|
|
|
|
for (q = p; *q && *q != ','; )
|
|
|
|
q++;
|
|
|
|
(void)strncpy(f->f_un.f_uname[i], p, UT_NAMESIZE);
|
|
|
|
if ((q - p) > UT_NAMESIZE)
|
|
|
|
f->f_un.f_uname[i][UT_NAMESIZE] = '\0';
|
|
|
|
else
|
|
|
|
f->f_un.f_uname[i][q - p] = '\0';
|
|
|
|
while (*q == ',' || *q == ' ')
|
|
|
|
q++;
|
|
|
|
p = q;
|
|
|
|
}
|
|
|
|
f->f_type = F_USERS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decode a symbolic name to a numeric value
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static int
|
|
|
|
decode(const char *name, CODE *codetab)
|
1994-05-26 05:23:31 +00:00
|
|
|
{
|
|
|
|
CODE *c;
|
|
|
|
char *p, buf[40];
|
|
|
|
|
|
|
|
if (isdigit(*name))
|
|
|
|
return (atoi(name));
|
|
|
|
|
|
|
|
for (p = buf; *name && p < &buf[sizeof(buf) - 1]; p++, name++) {
|
|
|
|
if (isupper(*name))
|
|
|
|
*p = tolower(*name);
|
|
|
|
else
|
|
|
|
*p = *name;
|
|
|
|
}
|
|
|
|
*p = '\0';
|
|
|
|
for (c = codetab; c->c_name; c++)
|
|
|
|
if (!strcmp(buf, c->c_name))
|
|
|
|
return (c->c_val);
|
|
|
|
|
|
|
|
return (-1);
|
|
|
|
}
|
1996-10-05 15:20:51 +00:00
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
2001-09-01 07:57:35 +00:00
|
|
|
markit(void)
|
|
|
|
{
|
|
|
|
struct filed *f;
|
2002-10-06 17:43:04 +00:00
|
|
|
dq_t q, next;
|
2001-09-01 07:57:35 +00:00
|
|
|
|
|
|
|
now = time((time_t *)NULL);
|
|
|
|
MarkSeq += TIMERINTVL;
|
|
|
|
if (MarkSeq >= MarkInterval) {
|
|
|
|
logmsg(LOG_INFO, "-- MARK --",
|
|
|
|
LocalHostName, ADDDATE|MARK);
|
|
|
|
MarkSeq = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (f = Files; f; f = f->f_next) {
|
|
|
|
if (f->f_prevcount && now >= REPEATTIME(f)) {
|
|
|
|
dprintf("flush %s: repeated %d times, %d sec.\n",
|
|
|
|
TypeNames[f->f_type], f->f_prevcount,
|
|
|
|
repeatinterval[f->f_repeatcount]);
|
|
|
|
fprintlog(f, 0, (char *)NULL);
|
|
|
|
BACKOFF(f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Walk the dead queue, and see if we should signal somebody. */
|
2002-10-06 17:43:04 +00:00
|
|
|
for (q = TAILQ_FIRST(&deadq_head); q != NULL; q = next) {
|
|
|
|
next = TAILQ_NEXT(q, dq_entries);
|
|
|
|
|
2001-09-01 07:57:35 +00:00
|
|
|
switch (q->dq_timeout) {
|
|
|
|
case 0:
|
|
|
|
/* Already signalled once, try harder now. */
|
|
|
|
if (kill(q->dq_pid, SIGKILL) != 0)
|
|
|
|
(void)deadq_remove(q->dq_pid);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
/*
|
|
|
|
* Timed out on dead queue, send terminate
|
|
|
|
* signal. Note that we leave the removal
|
|
|
|
* from the dead queue to reapchild(), which
|
|
|
|
* will also log the event (unless the process
|
|
|
|
* didn't even really exist, in case we simply
|
|
|
|
* drop it from the dead queue).
|
|
|
|
*/
|
|
|
|
if (kill(q->dq_pid, SIGTERM) != 0)
|
|
|
|
(void)deadq_remove(q->dq_pid);
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
|
|
|
default:
|
|
|
|
q->dq_timeout--;
|
|
|
|
}
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
2001-09-01 07:57:35 +00:00
|
|
|
MarkSet = 0;
|
|
|
|
(void)alarm(TIMERINTVL);
|
|
|
|
}
|
|
|
|
|
1996-11-18 21:48:29 +00:00
|
|
|
/*
|
|
|
|
* fork off and become a daemon, but wait for the child to come online
|
|
|
|
* before returing to the parent, or we get disk thrashing at boot etc.
|
|
|
|
* Set a timer so we don't hang forever if it wedges.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static int
|
|
|
|
waitdaemon(int nochdir, int noclose, int maxwait)
|
1996-10-05 15:20:51 +00:00
|
|
|
{
|
|
|
|
int fd;
|
1996-11-18 21:48:29 +00:00
|
|
|
int status;
|
|
|
|
pid_t pid, childpid;
|
1996-10-05 15:20:51 +00:00
|
|
|
|
1996-11-18 21:48:29 +00:00
|
|
|
switch (childpid = fork()) {
|
1996-10-05 15:20:51 +00:00
|
|
|
case -1:
|
|
|
|
return (-1);
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
default:
|
1996-11-18 21:48:29 +00:00
|
|
|
signal(SIGALRM, timedout);
|
1996-10-05 15:20:51 +00:00
|
|
|
alarm(maxwait);
|
1996-11-18 21:48:29 +00:00
|
|
|
while ((pid = wait3(&status, 0, NULL)) != -1) {
|
|
|
|
if (WIFEXITED(status))
|
|
|
|
errx(1, "child pid %d exited with return code %d",
|
|
|
|
pid, WEXITSTATUS(status));
|
|
|
|
if (WIFSIGNALED(status))
|
|
|
|
errx(1, "child pid %d exited on signal %d%s",
|
|
|
|
pid, WTERMSIG(status),
|
|
|
|
WCOREDUMP(status) ? " (core dumped)" :
|
|
|
|
"");
|
|
|
|
if (pid == childpid) /* it's gone... */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
exit(0);
|
1996-10-05 15:20:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (setsid() == -1)
|
|
|
|
return (-1);
|
|
|
|
|
|
|
|
if (!nochdir)
|
|
|
|
(void)chdir("/");
|
|
|
|
|
|
|
|
if (!noclose && (fd = open(_PATH_DEVNULL, O_RDWR, 0)) != -1) {
|
|
|
|
(void)dup2(fd, STDIN_FILENO);
|
|
|
|
(void)dup2(fd, STDOUT_FILENO);
|
|
|
|
(void)dup2(fd, STDERR_FILENO);
|
|
|
|
if (fd > 2)
|
|
|
|
(void)close (fd);
|
|
|
|
}
|
|
|
|
return (getppid());
|
|
|
|
}
|
1996-11-18 21:48:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We get a SIGALRM from the child when it's running and finished doing it's
|
|
|
|
* fsync()'s or O_SYNC writes for all the boot messages.
|
|
|
|
*
|
|
|
|
* We also get a signal from the kernel if the timer expires, so check to
|
|
|
|
* see what happened.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
timedout(int sig __unused)
|
1996-11-18 21:48:29 +00:00
|
|
|
{
|
|
|
|
int left;
|
|
|
|
left = alarm(0);
|
|
|
|
signal(SIGALRM, SIG_DFL);
|
|
|
|
if (left == 0)
|
|
|
|
errx(1, "timed out waiting for child");
|
|
|
|
else
|
2001-09-01 07:57:35 +00:00
|
|
|
_exit(0);
|
1996-11-18 21:48:29 +00:00
|
|
|
}
|
1997-02-22 12:59:36 +00:00
|
|
|
|
1997-05-03 22:17:43 +00:00
|
|
|
/*
|
|
|
|
* Add `s' to the list of allowable peer addresses to accept messages
|
|
|
|
* from.
|
|
|
|
*
|
|
|
|
* `s' is a string in the form:
|
|
|
|
*
|
|
|
|
* [*]domainname[:{servicename|portnumber|*}]
|
|
|
|
*
|
|
|
|
* or
|
|
|
|
*
|
|
|
|
* netaddr/maskbits[:{servicename|portnumber|*}]
|
|
|
|
*
|
|
|
|
* Returns -1 on error, 0 if the argument was valid.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static int
|
|
|
|
allowaddr(char *s)
|
1997-05-03 22:17:43 +00:00
|
|
|
{
|
|
|
|
char *cp1, *cp2;
|
|
|
|
struct allowedpeer ap;
|
|
|
|
struct servent *se;
|
2001-07-19 22:04:09 +00:00
|
|
|
int masklen = -1, i;
|
2000-12-16 18:25:48 +00:00
|
|
|
struct addrinfo hints, *res;
|
|
|
|
struct in_addr *addrp, *maskp;
|
2001-07-19 22:04:09 +00:00
|
|
|
u_int32_t *addr6p, *mask6p;
|
2000-12-16 18:25:48 +00:00
|
|
|
char ip[NI_MAXHOST];
|
|
|
|
|
|
|
|
#ifdef INET6
|
|
|
|
if (*s != '[' || (cp1 = strchr(s + 1, ']')) == NULL)
|
|
|
|
#endif
|
|
|
|
cp1 = s;
|
|
|
|
if ((cp1 = strrchr(cp1, ':'))) {
|
1997-05-03 22:17:43 +00:00
|
|
|
/* service/port provided */
|
|
|
|
*cp1++ = '\0';
|
|
|
|
if (strlen(cp1) == 1 && *cp1 == '*')
|
|
|
|
/* any port allowed */
|
2000-12-16 18:25:48 +00:00
|
|
|
ap.port = 0;
|
2002-03-24 06:02:10 +00:00
|
|
|
else if ((se = getservbyname(cp1, "udp"))) {
|
2000-12-16 18:25:48 +00:00
|
|
|
ap.port = ntohs(se->s_port);
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
2000-12-16 18:25:48 +00:00
|
|
|
ap.port = strtol(cp1, &cp2, 0);
|
1997-05-03 22:17:43 +00:00
|
|
|
if (*cp2 != '\0')
|
2002-03-24 05:52:04 +00:00
|
|
|
return (-1); /* port not numeric */
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if ((se = getservbyname("syslog", "udp")))
|
2000-12-16 18:25:48 +00:00
|
|
|
ap.port = ntohs(se->s_port);
|
1997-05-03 22:17:43 +00:00
|
|
|
else
|
|
|
|
/* sanity, should not happen */
|
2000-12-16 18:25:48 +00:00
|
|
|
ap.port = 514;
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
|
|
|
|
2000-12-16 18:25:48 +00:00
|
|
|
if ((cp1 = strchr(s, '/')) != NULL &&
|
|
|
|
strspn(cp1 + 1, "0123456789") == strlen(cp1 + 1)) {
|
|
|
|
*cp1 = '\0';
|
|
|
|
if ((masklen = atoi(cp1 + 1)) < 0)
|
2002-03-24 05:52:04 +00:00
|
|
|
return (-1);
|
2000-12-16 18:25:48 +00:00
|
|
|
}
|
|
|
|
#ifdef INET6
|
|
|
|
if (*s == '[') {
|
|
|
|
cp2 = s + strlen(s) - 1;
|
|
|
|
if (*cp2 == ']') {
|
|
|
|
++s;
|
|
|
|
*cp2 = '\0';
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
2000-12-16 18:25:48 +00:00
|
|
|
cp2 = NULL;
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
|
|
|
} else {
|
2000-12-16 18:25:48 +00:00
|
|
|
cp2 = NULL;
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
#endif
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_family = PF_UNSPEC;
|
|
|
|
hints.ai_socktype = SOCK_DGRAM;
|
|
|
|
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
|
|
|
|
if (getaddrinfo(s, NULL, &hints, &res) == 0) {
|
1997-05-03 22:17:43 +00:00
|
|
|
ap.isnumeric = 1;
|
2000-12-16 18:25:48 +00:00
|
|
|
memcpy(&ap.a_addr, res->ai_addr, res->ai_addrlen);
|
|
|
|
memset(&ap.a_mask, 0, sizeof(ap.a_mask));
|
|
|
|
ap.a_mask.ss_family = res->ai_family;
|
|
|
|
if (res->ai_family == AF_INET) {
|
|
|
|
ap.a_mask.ss_len = sizeof(struct sockaddr_in);
|
|
|
|
maskp = &((struct sockaddr_in *)&ap.a_mask)->sin_addr;
|
2001-07-02 15:26:47 +00:00
|
|
|
addrp = &((struct sockaddr_in *)&ap.a_addr)->sin_addr;
|
2000-12-16 18:25:48 +00:00
|
|
|
if (masklen < 0) {
|
|
|
|
/* use default netmask */
|
|
|
|
if (IN_CLASSA(ntohl(addrp->s_addr)))
|
|
|
|
maskp->s_addr = htonl(IN_CLASSA_NET);
|
|
|
|
else if (IN_CLASSB(ntohl(addrp->s_addr)))
|
|
|
|
maskp->s_addr = htonl(IN_CLASSB_NET);
|
|
|
|
else
|
|
|
|
maskp->s_addr = htonl(IN_CLASSC_NET);
|
|
|
|
} else if (masklen <= 32) {
|
|
|
|
/* convert masklen to netmask */
|
2001-11-14 09:20:24 +00:00
|
|
|
if (masklen == 0)
|
|
|
|
maskp->s_addr = 0;
|
|
|
|
else
|
|
|
|
maskp->s_addr = htonl(~((1 << (32 - masklen)) - 1));
|
2000-12-16 18:25:48 +00:00
|
|
|
} else {
|
|
|
|
freeaddrinfo(res);
|
2002-03-24 05:52:04 +00:00
|
|
|
return (-1);
|
2000-12-16 18:25:48 +00:00
|
|
|
}
|
2001-07-02 15:26:47 +00:00
|
|
|
/* Lose any host bits in the network number. */
|
|
|
|
addrp->s_addr &= maskp->s_addr;
|
2000-12-16 18:25:48 +00:00
|
|
|
}
|
|
|
|
#ifdef INET6
|
|
|
|
else if (res->ai_family == AF_INET6 && masklen <= 128) {
|
|
|
|
ap.a_mask.ss_len = sizeof(struct sockaddr_in6);
|
|
|
|
if (masklen < 0)
|
|
|
|
masklen = 128;
|
|
|
|
mask6p = (u_int32_t *)&((struct sockaddr_in6 *)&ap.a_mask)->sin6_addr;
|
1997-05-03 22:17:43 +00:00
|
|
|
/* convert masklen to netmask */
|
2000-12-16 18:25:48 +00:00
|
|
|
while (masklen > 0) {
|
|
|
|
if (masklen < 32) {
|
|
|
|
*mask6p = htonl(~(0xffffffff >> masklen));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
*mask6p++ = 0xffffffff;
|
|
|
|
masklen -= 32;
|
|
|
|
}
|
2001-07-19 22:04:09 +00:00
|
|
|
/* Lose any host bits in the network number. */
|
|
|
|
mask6p = (u_int32_t *)&((struct sockaddr_in6 *)&ap.a_mask)->sin6_addr;
|
|
|
|
addr6p = (u_int32_t *)&((struct sockaddr_in6 *)&ap.a_addr)->sin6_addr;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
|
|
addr6p[i] &= mask6p[i];
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
#endif
|
|
|
|
else {
|
|
|
|
freeaddrinfo(res);
|
2002-03-24 05:52:04 +00:00
|
|
|
return (-1);
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
freeaddrinfo(res);
|
1997-05-03 22:17:43 +00:00
|
|
|
} else {
|
|
|
|
/* arg `s' is domain name */
|
|
|
|
ap.isnumeric = 0;
|
|
|
|
ap.a_name = s;
|
2000-12-16 18:25:48 +00:00
|
|
|
if (cp1)
|
|
|
|
*cp1 = '/';
|
|
|
|
#ifdef INET6
|
|
|
|
if (cp2) {
|
|
|
|
*cp2 = ']';
|
|
|
|
--s;
|
|
|
|
}
|
|
|
|
#endif
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (Debug) {
|
|
|
|
printf("allowaddr: rule %d: ", NumAllowed);
|
|
|
|
if (ap.isnumeric) {
|
|
|
|
printf("numeric, ");
|
2000-12-16 18:25:48 +00:00
|
|
|
getnameinfo((struct sockaddr *)&ap.a_addr,
|
|
|
|
((struct sockaddr *)&ap.a_addr)->sa_len,
|
2005-05-13 16:31:11 +00:00
|
|
|
ip, sizeof ip, NULL, 0, NI_NUMERICHOST);
|
2000-12-16 18:25:48 +00:00
|
|
|
printf("addr = %s, ", ip);
|
|
|
|
getnameinfo((struct sockaddr *)&ap.a_mask,
|
|
|
|
((struct sockaddr *)&ap.a_mask)->sa_len,
|
2005-05-13 16:31:11 +00:00
|
|
|
ip, sizeof ip, NULL, 0, NI_NUMERICHOST);
|
2000-12-16 18:25:48 +00:00
|
|
|
printf("mask = %s; ", ip);
|
2002-03-24 06:02:10 +00:00
|
|
|
} else {
|
1997-05-03 22:17:43 +00:00
|
|
|
printf("domainname = %s; ", ap.a_name);
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
printf("port = %d\n", ap.port);
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((AllowedPeers = realloc(AllowedPeers,
|
|
|
|
++NumAllowed * sizeof(struct allowedpeer)))
|
|
|
|
== NULL) {
|
2001-09-30 16:09:17 +00:00
|
|
|
logerror("realloc");
|
|
|
|
exit(1);
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
|
|
|
memcpy(&AllowedPeers[NumAllowed - 1], &ap, sizeof(struct allowedpeer));
|
2002-03-24 05:52:04 +00:00
|
|
|
return (0);
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Validate that the remote peer has permission to log to us.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static int
|
|
|
|
validate(struct sockaddr *sa, const char *hname)
|
1997-05-03 22:17:43 +00:00
|
|
|
{
|
2000-12-16 18:25:48 +00:00
|
|
|
int i, j, reject;
|
1997-05-03 22:17:43 +00:00
|
|
|
size_t l1, l2;
|
2000-12-16 18:25:48 +00:00
|
|
|
char *cp, name[NI_MAXHOST], ip[NI_MAXHOST], port[NI_MAXSERV];
|
1997-05-03 22:17:43 +00:00
|
|
|
struct allowedpeer *ap;
|
2001-09-09 14:25:02 +00:00
|
|
|
struct sockaddr_in *sin4, *a4p = NULL, *m4p = NULL;
|
2000-12-16 18:25:48 +00:00
|
|
|
struct sockaddr_in6 *sin6, *a6p = NULL, *m6p = NULL;
|
|
|
|
struct addrinfo hints, *res;
|
|
|
|
u_short sport;
|
1997-05-03 22:17:43 +00:00
|
|
|
|
|
|
|
if (NumAllowed == 0)
|
|
|
|
/* traditional behaviour, allow everything */
|
2002-03-24 05:52:04 +00:00
|
|
|
return (1);
|
1997-05-03 22:17:43 +00:00
|
|
|
|
2001-09-01 07:57:35 +00:00
|
|
|
(void)strlcpy(name, hname, sizeof(name));
|
2000-12-16 18:25:48 +00:00
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_family = PF_UNSPEC;
|
|
|
|
hints.ai_socktype = SOCK_DGRAM;
|
|
|
|
hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
|
|
|
|
if (getaddrinfo(name, NULL, &hints, &res) == 0)
|
|
|
|
freeaddrinfo(res);
|
|
|
|
else if (strchr(name, '.') == NULL) {
|
2000-06-08 03:54:45 +00:00
|
|
|
strlcat(name, ".", sizeof name);
|
|
|
|
strlcat(name, LocalDomain, sizeof name);
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
if (getnameinfo(sa, sa->sa_len, ip, sizeof ip, port, sizeof port,
|
2005-05-13 16:31:11 +00:00
|
|
|
NI_NUMERICHOST | NI_NUMERICSERV) != 0)
|
2002-03-24 05:52:04 +00:00
|
|
|
return (0); /* for safety, should not occur */
|
2000-12-16 18:25:48 +00:00
|
|
|
dprintf("validate: dgram from IP %s, port %s, name %s;\n",
|
|
|
|
ip, port, name);
|
|
|
|
sport = atoi(port);
|
1997-05-03 22:17:43 +00:00
|
|
|
|
|
|
|
/* now, walk down the list */
|
|
|
|
for (i = 0, ap = AllowedPeers; i < NumAllowed; i++, ap++) {
|
2000-12-16 18:25:48 +00:00
|
|
|
if (ap->port != 0 && ap->port != sport) {
|
1997-05-03 22:17:43 +00:00
|
|
|
dprintf("rejected in rule %d due to port mismatch.\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ap->isnumeric) {
|
2000-12-16 18:25:48 +00:00
|
|
|
if (ap->a_addr.ss_family != sa->sa_family) {
|
|
|
|
dprintf("rejected in rule %d due to address family mismatch.\n", i);
|
1997-05-03 22:17:43 +00:00
|
|
|
continue;
|
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
if (ap->a_addr.ss_family == AF_INET) {
|
2001-09-09 14:25:02 +00:00
|
|
|
sin4 = (struct sockaddr_in *)sa;
|
2000-12-16 18:25:48 +00:00
|
|
|
a4p = (struct sockaddr_in *)&ap->a_addr;
|
|
|
|
m4p = (struct sockaddr_in *)&ap->a_mask;
|
2001-09-09 14:25:02 +00:00
|
|
|
if ((sin4->sin_addr.s_addr & m4p->sin_addr.s_addr)
|
2000-12-16 18:25:48 +00:00
|
|
|
!= a4p->sin_addr.s_addr) {
|
|
|
|
dprintf("rejected in rule %d due to IP mismatch.\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef INET6
|
|
|
|
else if (ap->a_addr.ss_family == AF_INET6) {
|
|
|
|
sin6 = (struct sockaddr_in6 *)sa;
|
|
|
|
a6p = (struct sockaddr_in6 *)&ap->a_addr;
|
|
|
|
m6p = (struct sockaddr_in6 *)&ap->a_mask;
|
|
|
|
if (a6p->sin6_scope_id != 0 &&
|
|
|
|
sin6->sin6_scope_id != a6p->sin6_scope_id) {
|
|
|
|
dprintf("rejected in rule %d due to scope mismatch.\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
reject = 0;
|
|
|
|
for (j = 0; j < 16; j += 4) {
|
2001-07-19 22:04:09 +00:00
|
|
|
if ((*(u_int32_t *)&sin6->sin6_addr.s6_addr[j] & *(u_int32_t *)&m6p->sin6_addr.s6_addr[j])
|
|
|
|
!= *(u_int32_t *)&a6p->sin6_addr.s6_addr[j]) {
|
2000-12-16 18:25:48 +00:00
|
|
|
++reject;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (reject) {
|
|
|
|
dprintf("rejected in rule %d due to IP mismatch.\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
else
|
|
|
|
continue;
|
1997-05-03 22:17:43 +00:00
|
|
|
} else {
|
|
|
|
cp = ap->a_name;
|
|
|
|
l1 = strlen(name);
|
|
|
|
if (*cp == '*') {
|
|
|
|
/* allow wildmatch */
|
|
|
|
cp++;
|
|
|
|
l2 = strlen(cp);
|
|
|
|
if (l2 > l1 || memcmp(cp, &name[l1 - l2], l2) != 0) {
|
|
|
|
dprintf("rejected in rule %d due to name mismatch.\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* exact match */
|
|
|
|
l2 = strlen(cp);
|
|
|
|
if (l2 != l1 || memcmp(cp, name, l1) != 0) {
|
|
|
|
dprintf("rejected in rule %d due to name mismatch.\n", i);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dprintf("accepted in rule %d.\n", i);
|
2002-03-24 05:52:04 +00:00
|
|
|
return (1); /* hooray! */
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
2002-03-24 05:52:04 +00:00
|
|
|
return (0);
|
1997-05-03 22:17:43 +00:00
|
|
|
}
|
|
|
|
|
1997-02-22 12:59:36 +00:00
|
|
|
/*
|
|
|
|
* Fairly similar to popen(3), but returns an open descriptor, as
|
|
|
|
* opposed to a FILE *.
|
|
|
|
*/
|
2002-03-24 05:48:37 +00:00
|
|
|
static int
|
2004-05-30 00:02:19 +00:00
|
|
|
p_open(const char *prog, pid_t *rpid)
|
1997-02-22 12:59:36 +00:00
|
|
|
{
|
|
|
|
int pfd[2], nulldesc, i;
|
2004-05-30 00:02:19 +00:00
|
|
|
pid_t pid;
|
1997-02-22 12:59:36 +00:00
|
|
|
sigset_t omask, mask;
|
|
|
|
char *argv[4]; /* sh -c cmd NULL */
|
|
|
|
char errmsg[200];
|
|
|
|
|
|
|
|
if (pipe(pfd) == -1)
|
2002-03-24 05:52:04 +00:00
|
|
|
return (-1);
|
1997-02-22 12:59:36 +00:00
|
|
|
if ((nulldesc = open(_PATH_DEVNULL, O_RDWR)) == -1)
|
|
|
|
/* we are royally screwed anyway */
|
2002-03-24 05:52:04 +00:00
|
|
|
return (-1);
|
1997-02-22 12:59:36 +00:00
|
|
|
|
1998-02-28 15:14:00 +00:00
|
|
|
sigemptyset(&mask);
|
|
|
|
sigaddset(&mask, SIGALRM);
|
|
|
|
sigaddset(&mask, SIGHUP);
|
|
|
|
sigprocmask(SIG_BLOCK, &mask, &omask);
|
2004-05-30 00:02:19 +00:00
|
|
|
switch ((pid = fork())) {
|
1997-02-22 12:59:36 +00:00
|
|
|
case -1:
|
1998-02-28 15:14:00 +00:00
|
|
|
sigprocmask(SIG_SETMASK, &omask, 0);
|
1997-02-22 12:59:36 +00:00
|
|
|
close(nulldesc);
|
2002-03-24 05:52:04 +00:00
|
|
|
return (-1);
|
1997-02-22 12:59:36 +00:00
|
|
|
|
|
|
|
case 0:
|
2001-09-09 14:25:02 +00:00
|
|
|
argv[0] = strdup("sh");
|
|
|
|
argv[1] = strdup("-c");
|
|
|
|
argv[2] = strdup(prog);
|
1997-02-22 12:59:36 +00:00
|
|
|
argv[3] = NULL;
|
2001-09-30 16:09:17 +00:00
|
|
|
if (argv[0] == NULL || argv[1] == NULL || argv[2] == NULL) {
|
|
|
|
logerror("strdup");
|
|
|
|
exit(1);
|
|
|
|
}
|
1997-02-22 12:59:36 +00:00
|
|
|
|
|
|
|
alarm(0);
|
|
|
|
(void)setsid(); /* Avoid catching SIGHUPs. */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Throw away pending signals, and reset signal
|
|
|
|
* behaviour to standard values.
|
|
|
|
*/
|
|
|
|
signal(SIGALRM, SIG_IGN);
|
|
|
|
signal(SIGHUP, SIG_IGN);
|
1998-02-28 15:14:00 +00:00
|
|
|
sigprocmask(SIG_SETMASK, &omask, 0);
|
1997-02-22 12:59:36 +00:00
|
|
|
signal(SIGPIPE, SIG_DFL);
|
|
|
|
signal(SIGQUIT, SIG_DFL);
|
|
|
|
signal(SIGALRM, SIG_DFL);
|
|
|
|
signal(SIGHUP, SIG_DFL);
|
|
|
|
|
|
|
|
dup2(pfd[0], STDIN_FILENO);
|
|
|
|
dup2(nulldesc, STDOUT_FILENO);
|
|
|
|
dup2(nulldesc, STDERR_FILENO);
|
|
|
|
for (i = getdtablesize(); i > 2; i--)
|
2002-03-24 06:02:10 +00:00
|
|
|
(void)close(i);
|
1997-02-22 12:59:36 +00:00
|
|
|
|
2002-03-24 06:02:10 +00:00
|
|
|
(void)execvp(_PATH_BSHELL, argv);
|
1997-02-22 12:59:36 +00:00
|
|
|
_exit(255);
|
|
|
|
}
|
|
|
|
|
1998-02-28 15:14:00 +00:00
|
|
|
sigprocmask(SIG_SETMASK, &omask, 0);
|
1997-02-22 12:59:36 +00:00
|
|
|
close(nulldesc);
|
|
|
|
close(pfd[0]);
|
|
|
|
/*
|
|
|
|
* Avoid blocking on a hung pipe. With O_NONBLOCK, we are
|
|
|
|
* supposed to get an EWOULDBLOCK on writev(2), which is
|
|
|
|
* caught by the logic above anyway, which will in turn close
|
|
|
|
* the pipe, and fork a new logging subprocess if necessary.
|
|
|
|
* The stale subprocess will be killed some time later unless
|
|
|
|
* it terminated itself due to closing its input pipe (so we
|
|
|
|
* get rid of really dead puppies).
|
|
|
|
*/
|
|
|
|
if (fcntl(pfd[1], F_SETFL, O_NONBLOCK) == -1) {
|
|
|
|
/* This is bad. */
|
|
|
|
(void)snprintf(errmsg, sizeof errmsg,
|
|
|
|
"Warning: cannot change pipe to PID %d to "
|
|
|
|
"non-blocking behaviour.",
|
2004-05-30 00:02:19 +00:00
|
|
|
(int)pid);
|
1997-02-22 12:59:36 +00:00
|
|
|
logerror(errmsg);
|
|
|
|
}
|
2004-05-30 00:02:19 +00:00
|
|
|
*rpid = pid;
|
2002-03-24 05:52:04 +00:00
|
|
|
return (pfd[1]);
|
1997-02-22 12:59:36 +00:00
|
|
|
}
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
deadq_enter(pid_t pid, const char *name)
|
1997-02-22 12:59:36 +00:00
|
|
|
{
|
|
|
|
dq_t p;
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
int status;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Be paranoid, if we can't signal the process, don't enter it
|
|
|
|
* into the dead queue (perhaps it's already dead). If possible,
|
|
|
|
* we try to fetch and log the child's status.
|
|
|
|
*/
|
|
|
|
if (kill(pid, 0) != 0) {
|
|
|
|
if (waitpid(pid, &status, WNOHANG) > 0)
|
|
|
|
log_deadchild(pid, status, name);
|
|
|
|
return;
|
|
|
|
}
|
1997-02-22 12:59:36 +00:00
|
|
|
|
|
|
|
p = malloc(sizeof(struct deadq_entry));
|
2001-09-13 06:48:41 +00:00
|
|
|
if (p == NULL) {
|
2001-09-30 16:09:17 +00:00
|
|
|
logerror("malloc");
|
1997-02-22 12:59:36 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
p->dq_pid = pid;
|
|
|
|
p->dq_timeout = DQ_TIMO_INIT;
|
|
|
|
TAILQ_INSERT_TAIL(&deadq_head, p, dq_entries);
|
|
|
|
}
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static int
|
|
|
|
deadq_remove(pid_t pid)
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
{
|
|
|
|
dq_t q;
|
|
|
|
|
2002-03-24 06:02:10 +00:00
|
|
|
TAILQ_FOREACH(q, &deadq_head, dq_entries) {
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
if (q->dq_pid == pid) {
|
|
|
|
TAILQ_REMOVE(&deadq_head, q, dq_entries);
|
|
|
|
free(q);
|
2002-03-24 05:52:04 +00:00
|
|
|
return (1);
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
}
|
2002-03-24 06:02:10 +00:00
|
|
|
}
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
|
2002-03-24 05:52:04 +00:00
|
|
|
return (0);
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
}
|
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static void
|
|
|
|
log_deadchild(pid_t pid, int status, const char *name)
|
Fix a serious bug in syslogd regarding the handling of pipes. The bug
would cause syslogd to eventually kill innocent processes in the
system over time (note: not `could' but `would'). Many thanks to my
colleague Mirko for digging into the kernel structures and providing
me with the debugging framework to find out about the nature of this
bug (and to isolate that syslogd was the culprit) in a rather large
set of distributed machines at client sites where this happened
occasionally.
Whenever a child process was no longer responsive, or when syslogd
receives a SIGHUP so it closes all its logging file descriptors, for
any descriptor that refers to a pipe syslogd enters the data about the
old logging child process into a `dead queue', where it is being
removed from (and the status of the dead kitten being fetched) upon
receipt of a SIGCHLD. However, there's a high probability that the
SIGCHLD already arrives before the child's data are actually entered
into the dead queue inside the SIGHUP handler, so the SIGCHLD handler
has nothing to fetch and remove and simply continues. Whenever this
happens, the process'es data remain on the dead queue forever, and
since domark() tried to get rid of totally unresponsive children by
first sending a SIGTERM and later a SIGKILL, it was only a matter of
time until the system had recycled enough PIDs so an innocent process
got shot to death.
Fix the race by masking SIGHUP and SIGCHLD from both handlers mutually.
Add additional bandaids ``just in case'', i. e. don't enter a process
into the dead queue if we can't signal it (this should only happen in
case it is already dead by that time so we can fetch the status
immediately instead of deferring this to the SIGCHLD handler); for the
kill(2) inside domark(), check for an error status (/* Can't happen */
:) and remove it from the dead queue in this case (which if it would
have been there in the first place would have reduced the problem to a
statistically minimal likelihood so i certainly would never have
noticed the bug at all :).
Mirko also reviewed the fix in priciple (mutual blocking of both
signals inside the handlers), but not the actual code.
Reviewed by: Mirko Kaffka <mirko@interface-business.de>
Approved by: jkh
2000-02-28 17:49:43 +00:00
|
|
|
{
|
|
|
|
int code;
|
|
|
|
char buf[256];
|
|
|
|
const char *reason;
|
|
|
|
|
|
|
|
errno = 0; /* Keep strerror() stuff out of logerror messages. */
|
|
|
|
if (WIFSIGNALED(status)) {
|
|
|
|
reason = "due to signal";
|
|
|
|
code = WTERMSIG(status);
|
|
|
|
} else {
|
|
|
|
reason = "with status";
|
|
|
|
code = WEXITSTATUS(status);
|
|
|
|
if (code == 0)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
(void)snprintf(buf, sizeof buf,
|
|
|
|
"Logging subprocess %d (%s) exited %s %d.",
|
|
|
|
pid, name, reason, code);
|
|
|
|
logerror(buf);
|
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
|
2002-03-24 05:48:37 +00:00
|
|
|
static int *
|
|
|
|
socksetup(int af, const char *bindhostname)
|
2000-12-16 18:25:48 +00:00
|
|
|
{
|
|
|
|
struct addrinfo hints, *res, *r;
|
|
|
|
int error, maxs, *s, *socks;
|
|
|
|
|
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_flags = AI_PASSIVE;
|
|
|
|
hints.ai_family = af;
|
|
|
|
hints.ai_socktype = SOCK_DGRAM;
|
2001-09-01 08:42:49 +00:00
|
|
|
error = getaddrinfo(bindhostname, "syslog", &hints, &res);
|
2000-12-16 18:25:48 +00:00
|
|
|
if (error) {
|
|
|
|
logerror(gai_strerror(error));
|
|
|
|
errno = 0;
|
|
|
|
die(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Count max number of sockets we may open */
|
|
|
|
for (maxs = 0, r = res; r; r = r->ai_next, maxs++);
|
|
|
|
socks = malloc((maxs+1) * sizeof(int));
|
2001-09-13 06:48:41 +00:00
|
|
|
if (socks == NULL) {
|
2000-12-16 18:25:48 +00:00
|
|
|
logerror("couldn't allocate memory for sockets");
|
|
|
|
die(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
*socks = 0; /* num of sockets counter at start of array */
|
|
|
|
s = socks + 1;
|
|
|
|
for (r = res; r; r = r->ai_next) {
|
2005-09-28 16:05:13 +00:00
|
|
|
int on = 1;
|
2000-12-16 18:25:48 +00:00
|
|
|
*s = socket(r->ai_family, r->ai_socktype, r->ai_protocol);
|
|
|
|
if (*s < 0) {
|
|
|
|
logerror("socket");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (r->ai_family == AF_INET6) {
|
2002-07-22 15:22:53 +00:00
|
|
|
if (setsockopt(*s, IPPROTO_IPV6, IPV6_V6ONLY,
|
2000-12-16 18:25:48 +00:00
|
|
|
(char *)&on, sizeof (on)) < 0) {
|
|
|
|
logerror("setsockopt");
|
|
|
|
close(*s);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2005-09-28 16:05:13 +00:00
|
|
|
if (setsockopt(*s, SOL_SOCKET, SO_REUSEADDR,
|
2005-09-28 16:14:43 +00:00
|
|
|
(char *)&on, sizeof (on)) < 0) {
|
2005-09-28 16:05:13 +00:00
|
|
|
logerror("setsockopt");
|
|
|
|
close(*s);
|
|
|
|
continue;
|
|
|
|
}
|
2000-12-16 18:25:48 +00:00
|
|
|
if (bind(*s, r->ai_addr, r->ai_addrlen) < 0) {
|
|
|
|
close(*s);
|
|
|
|
logerror("bind");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2004-11-11 09:39:04 +00:00
|
|
|
double_rbuf(*s);
|
|
|
|
|
2000-12-16 18:25:48 +00:00
|
|
|
(*socks)++;
|
|
|
|
s++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*socks == 0) {
|
|
|
|
free(socks);
|
|
|
|
if (Debug)
|
2002-03-24 05:52:04 +00:00
|
|
|
return (NULL);
|
2000-12-16 18:25:48 +00:00
|
|
|
else
|
|
|
|
die(0);
|
|
|
|
}
|
|
|
|
if (res)
|
|
|
|
freeaddrinfo(res);
|
|
|
|
|
2002-03-24 05:52:04 +00:00
|
|
|
return (socks);
|
2000-12-16 18:25:48 +00:00
|
|
|
}
|
2004-11-11 09:39:04 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
double_rbuf(int fd)
|
|
|
|
{
|
|
|
|
socklen_t slen, len;
|
|
|
|
|
|
|
|
if (getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, &slen) == 0) {
|
|
|
|
len *= 2;
|
|
|
|
setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &len, slen);
|
|
|
|
}
|
|
|
|
}
|