Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/rdist/message.c	Lines:	0	211	0.0 %
Date:	2017-11-07	Branches:	0	192	0.0 %


/*	$OpenBSD: message.c,v 1.28 2016/03/30 20:51:59 millert Exp $	*/

/*
 * Copyright (c) 1983 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.
 * 3. 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.
 */

#include <errno.h>
#include <limits.h>
#include <paths.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>

#include "defs.h"

/*
 * Message handling functions for both rdist and rdistd.
 */


#define MSGBUFSIZ	32*1024

int			debug = 0;		/* Debugging level */
int			nerrs = 0;		/* Number of errors */

/*
 * Message Types
 */
struct msgtype {
	int		mt_type;		/* Type (bit) */
	char	       *mt_name;		/* Name of message type */
} msgtypes[] = {
	{ MT_CHANGE,	"change" },
	{ MT_INFO,	"info" },
	{ MT_NOTICE,	"notice" },
	{ MT_NERROR,	"nerror" },
	{ MT_FERROR,	"ferror" },
	{ MT_WARNING,	"warning" },
	{ MT_VERBOSE,	"verbose" },
	{ MT_ALL,	"all" },
	{ MT_DEBUG,	"debug" },
	{ 0 },
};

/*
 * Description of message facilities
 */
struct msgfacility {
	/* compile time initialized data */
	int		mf_msgfac;		/* One of MF_* from below */
	char	       *mf_name;		/* Name of this facility */
	void	      (*mf_sendfunc)		/* Function to send msg */
			(struct msgfacility *, int, int, char *);
	/* run time initialized data */
	int		mf_msgtypes;		/* Bitmask of MT_* from above*/
	char	       *mf_filename;		/* Name of file */
	FILE	       *mf_fptr;		/* File pointer to output to */
};

/*
 * Message Facilities
 */
#define MF_STDOUT	1			/* Standard Output */
#define MF_NOTIFY	2			/* Notify mail service */
#define MF_FILE		3			/* A normal file */
#define MF_SYSLOG	4			/* syslog() */

static void msgsendstdout(struct msgfacility *, int, int, char *);
static void msgsendsyslog(struct msgfacility *, int, int, char *);
static void msgsendfile(struct msgfacility *, int, int, char *);
static void msgsendnotify(struct msgfacility *, int, int, char *);

/*
 * Message Facilities
 */
struct msgfacility msgfacility[] = {
	{ MF_STDOUT,	"stdout",	msgsendstdout },
	{ MF_FILE,	"file",		msgsendfile },
	{ MF_SYSLOG,	"syslog",	msgsendsyslog },
	{ MF_NOTIFY,	"notify",	msgsendnotify },
	{ 0 },
};

static struct msgfacility *getmsgfac(char *);
static struct msgtype *getmsgtype(char *);
static char *setmsgtypes(struct msgfacility *, char *);
static void _message(int, char *);
static void _debugmsg(int, char *);
static void _error(const char *);
static void _fatalerr(const char *);

/*
 * Print message logging usage message
 */
void
msgprusage(void)
{
	int i, x;

	(void) fprintf(stderr, "\nWhere <msgopt> is of form\n");
	(void) fprintf(stderr,
       "\t<facility1>=<type1>,<type2>,...:<facility2>=<type1>,<type2>...\n");

	(void) fprintf(stderr, "Valid <facility> names:");

	for (i = 0; msgfacility[i].mf_name; ++i)
		(void) fprintf(stderr, " %s", msgfacility[i].mf_name);

	(void) fprintf(stderr, "\nValid <type> names:");
	for (x = 0; msgtypes[x].mt_name; ++x)
		(void) fprintf(stderr, " %s", msgtypes[x].mt_name);

	(void) fprintf(stderr, "\n");
}

/*
 * Print enabled message logging info
 */
void
msgprconfig(void)
{
	int i, x;
	static char buf[MSGBUFSIZ];

	debugmsg(DM_MISC, "Current message logging config:");
	for (i = 0; msgfacility[i].mf_name; ++i) {
		(void) snprintf(buf, sizeof(buf), "    %.*s=",
			       (int)(sizeof(buf) - 7), msgfacility[i].mf_name);
		for (x = 0; msgtypes[x].mt_name; ++x)
			if (IS_ON(msgfacility[i].mf_msgtypes,
				  msgtypes[x].mt_type)) {
				if (x > 0)
					(void) strlcat(buf, ",", sizeof(buf));
				(void) strlcat(buf, msgtypes[x].mt_name,
				    sizeof(buf));
			}
		debugmsg(DM_MISC, "%s", buf);
	}

}

/*
 * Get the Message Facility entry "name"
 */
static struct msgfacility *
getmsgfac(char *name)
{
	int i;

	for (i = 0; msgfacility[i].mf_name; ++i)
		if (strcasecmp(name, msgfacility[i].mf_name) == 0)
			return(&msgfacility[i]);

	return(NULL);
}

/*
 * Get the Message Type entry named "name"
 */
static struct msgtype *
getmsgtype(char *name)
{
	int i;

	for (i = 0; msgtypes[i].mt_name; ++i)
		if (strcasecmp(name, msgtypes[i].mt_name) == 0)
			return(&msgtypes[i]);

	return(NULL);
}

/*
 * Set Message Type information for Message Facility "msgfac" as
 * indicated by string "str".
 */
static char *
setmsgtypes(struct msgfacility *msgfac, char *str)
{
	static char ebuf[BUFSIZ];
	char *cp;
	char *strptr, *word;
	struct msgtype *mtp;

	/*
	 * MF_SYSLOG is the only supported message facility for the server
	 */
	if (isserver && (msgfac->mf_msgfac != MF_SYSLOG &&
			 msgfac->mf_msgfac != MF_FILE)) {
		(void) snprintf(ebuf, sizeof(ebuf),
		"The \"%.*s\" message facility cannot be used by the server.",
			        100, msgfac->mf_name);
		return(ebuf);
	}

	strptr = str;

	/*
	 * Do any necessary Message Facility preparation
	 */
	switch(msgfac->mf_msgfac) {
	case MF_FILE:
		/*
		 * The MF_FILE string should look like "<file>=<types>".
		 */
		if ((cp = strchr(strptr, '=')) == NULL)
			return(
			   "No file name found for \"file\" message facility");
		*cp++ = CNULL;

		if ((msgfac->mf_fptr = fopen(strptr, "w")) == NULL)
			fatalerr("Cannot open log file for writing: %s: %s.",
				 strptr, SYSERR);
		msgfac->mf_filename = xstrdup(strptr);

		strptr = cp;
		break;

	case MF_NOTIFY:
		break;

	case MF_STDOUT:
		msgfac->mf_fptr = stdout;
		break;

	case MF_SYSLOG:
		openlog(progname, LOG_PID, LOG_DAEMON);
		break;
	}

	/*
	 * Parse each type word
	 */
	msgfac->mf_msgtypes = 0;	/* Start from scratch */
	while (strptr) {
		word = strptr;
		if ((cp = strchr(strptr, ',')) != NULL)
			*cp++ = CNULL;
		strptr = cp;

		if ((mtp = getmsgtype(word)) != NULL) {
			msgfac->mf_msgtypes |= mtp->mt_type;
			/*
			 * XXX This is really a kludge until we add real
			 * control over debugging.
			 */
			if (!debug && isserver &&
			    strcasecmp(word, "debug") == 0)
				debug = DM_ALL;
		} else {
			(void) snprintf(ebuf, sizeof(ebuf),
				        "Message type \"%.*s\" is invalid.",
				        100, word);
			return(ebuf);
		}
	}

	return(NULL);
}

/*
 * Parse a message logging option string
 */
char *
msgparseopts(char *msgstr, int doset)
{
	static char ebuf[BUFSIZ], msgbuf[MSGBUFSIZ];
	char *cp, *optstr;
	char *word;
	struct msgfacility *msgfac;

	if (msgstr == NULL)
		return("NULL message string");

	/* strtok() is harmful */
	(void) strlcpy(msgbuf, msgstr, sizeof(msgbuf));

	/*
	 * Each <facility>=<types> list is separated by ":".
	 */
	for (optstr = strtok(msgbuf, ":"); optstr;
	     optstr = strtok(NULL, ":")) {

		if ((cp = strchr(optstr, '=')) == NULL)
			return("No '=' found");

		*cp++ = CNULL;
		word = optstr;
		if ((int)strlen(word) <= 0)
			return("No message facility specified");
		if ((int)strlen(cp) <= 0)
			return("No message type specified");

		if ((msgfac = getmsgfac(word)) == NULL) {
			(void) snprintf(ebuf, sizeof(ebuf),
				        "%.*s is not a valid message facility",
				        100, word);
			return(ebuf);
		}

		if (doset) {
			char *mcp;

			if ((mcp = setmsgtypes(msgfac, cp)) != NULL)
				return(mcp);
		}
	}

	if (isserver && debug) {
		debugmsg(DM_MISC, "%s", getversion());
		msgprconfig();
	}

	return(NULL);
}

/*
 * Send a message to facility "stdout".
 * For rdistd, this is really the rdist client.
 */
static void
msgsendstdout(struct msgfacility *msgfac, int mtype, int flags, char *msgbuf)
{
	char cmd;

	if (isserver) {
		if (rem_w < 0 || IS_ON(flags, MT_NOREMOTE))
			return;

		cmd = CNULL;

		switch(mtype) {
		case MT_NERROR:		cmd = C_ERRMSG;		break;
		case MT_FERROR:		cmd = C_FERRMSG;	break;
		case MT_NOTICE:		cmd = C_NOTEMSG;	break;
		case MT_REMOTE:		cmd = C_LOGMSG;		break;
		}

		if (cmd != CNULL)
			(void) sendcmd(cmd, "%s", msgbuf);
	} else {
		switch(mtype) {
		case MT_FERROR:
		case MT_NERROR:
			if (msgbuf && *msgbuf) {
				(void) fprintf(stderr, "%s\n", msgbuf);
				(void) fflush(stderr);
			}
			break;

		case MT_DEBUG:
			/*
			 * Only things that are strictly MT_DEBUG should
			 * be shown.
			 */
			if (flags != MT_DEBUG)
				return;
		case MT_NOTICE:
		case MT_CHANGE:
		case MT_INFO:
		case MT_VERBOSE:
		case MT_WARNING:
			if (msgbuf && *msgbuf) {
				(void) printf("%s\n", msgbuf);
				(void) fflush(stdout);
			}
			break;
		}
	}
}

/*
 * Send a message to facility "syslog"
 */
static void
msgsendsyslog(struct msgfacility *msgfac, int mtype, int flags, char *msgbuf)
{
	int syslvl = 0;

	if (!msgbuf || !*msgbuf)
		return;

	switch(mtype) {
#if	defined(SL_NERROR)
	case MT_NERROR:		syslvl = SL_NERROR;	break;
#endif
#if	defined(SL_FERROR)
	case MT_FERROR:		syslvl = SL_FERROR;	break;
#endif
#if	defined(SL_WARNING)
	case MT_WARNING:	syslvl = SL_WARNING;	break;
#endif
#if	defined(SL_CHANGE)
	case MT_CHANGE:		syslvl = SL_CHANGE;	break;
#endif
#if	defined(SL_INFO)
	case MT_SYSLOG:
	case MT_VERBOSE:
	case MT_INFO:		syslvl = SL_INFO;	break;
#endif
#if	defined(SL_NOTICE)
	case MT_NOTICE:		syslvl = SL_NOTICE;	break;
#endif
#if	defined(SL_DEBUG)
	case MT_DEBUG:		syslvl = SL_DEBUG;	break;
#endif
	}

	if (syslvl)
		syslog(syslvl, "%s", msgbuf);
}

/*
 * Send a message to a "file" facility.
 */
static void
msgsendfile(struct msgfacility *msgfac, int mtype, int flags, char *msgbuf)
{
	if (msgfac->mf_fptr == NULL)
		return;

	if (!msgbuf || !*msgbuf)
		return;

	(void) fprintf(msgfac->mf_fptr, "%s\n", msgbuf);
	(void) fflush(msgfac->mf_fptr);
}

/*
 * Same method as msgsendfile()
 */
static void
msgsendnotify(struct msgfacility *msgfac, int mtype, int flags, char *msgbuf)
{
	char *tempfile;

	if (IS_ON(flags, MT_DEBUG))
		return;

	if (!msgbuf || !*msgbuf)
		return;

	if (!msgfac->mf_fptr) {
		char *cp;
		int fd;
		size_t len;

		/*
		 * Create and open a new temporary file
		 */
		if ((cp = getenv("TMPDIR")) == NULL || *cp == '\0')
			cp = _PATH_TMP;
		len = strlen(cp) + 1 + sizeof(_RDIST_TMP);
		tempfile = xmalloc(len);
		(void) snprintf(tempfile, len, "%s/%s", cp, _RDIST_TMP);

		msgfac->mf_filename = tempfile;
		if ((fd = mkstemp(msgfac->mf_filename)) < 0 ||
		    (msgfac->mf_fptr = fdopen(fd, "w")) == NULL)
		    fatalerr("Cannot open notify file for writing: %s: %s.",
			msgfac->mf_filename, SYSERR);
		debugmsg(DM_MISC, "Created notify temp file '%s'",
			 msgfac->mf_filename);
	}

	if (msgfac->mf_fptr == NULL)
		return;

	(void) fprintf(msgfac->mf_fptr, "%s\n", msgbuf);
	(void) fflush(msgfac->mf_fptr);
}

/*
 * Insure currenthost is set to something reasonable.
 */
void
checkhostname(void)
{
	static char mbuf[HOST_NAME_MAX+1];
	char *cp;

	if (!currenthost) {
		if (gethostname(mbuf, sizeof(mbuf)) == 0) {
			if ((cp = strchr(mbuf, '.')) != NULL)
				*cp = CNULL;
			currenthost = xstrdup(mbuf);
		} else
			currenthost = "(unknown)";
	}
}

/*
 * Print a message contained in "msgbuf" if a level "lvl" is set.
 */
static void
_message(int flags, char *msgbuf)
{
	int i, x;
	static char mbuf[2048];

	if (msgbuf && *msgbuf) {
		/*
		 * Ensure no stray newlines are present
		 */
		msgbuf[strcspn(msgbuf, "\n")] = CNULL;

		checkhostname();
		if (strncmp(currenthost, msgbuf, strlen(currenthost)) == 0)
			(void) strlcpy(mbuf, msgbuf, sizeof(mbuf));
		else
			(void) snprintf(mbuf, sizeof(mbuf),
					"%s: %s", currenthost, msgbuf);
	} else
		mbuf[0] = '\0';

	/*
	 * Special case for messages that only get
	 * logged to the system log facility
	 */
	if (IS_ON(flags, MT_SYSLOG)) {
		msgsendsyslog(NULL, MT_SYSLOG, flags, mbuf);
		return;
	}

	/*
	 * Special cases
	 */
	if (isserver && IS_ON(flags, MT_NOTICE)) {
		msgsendstdout(NULL, MT_NOTICE, flags, mbuf);
		return;
	} else if (isserver && IS_ON(flags, MT_REMOTE))
		msgsendstdout(NULL, MT_REMOTE, flags, mbuf);
	else if (isserver && IS_ON(flags, MT_NERROR))
		msgsendstdout(NULL, MT_NERROR, flags, mbuf);
	else if (isserver && IS_ON(flags, MT_FERROR))
		msgsendstdout(NULL, MT_FERROR, flags, mbuf);

	/*
	 * For each Message Facility, check each Message Type to see
	 * if the bits in "flags" are set.  If so, call the appropriate
	 * Message Facility to dispatch the message.
	 */
	for (i = 0; msgfacility[i].mf_name; ++i)
		for (x = 0; msgtypes[x].mt_name; ++x)
			/*
			 * XXX MT_ALL should not be used directly
			 */
			if (msgtypes[x].mt_type != MT_ALL &&
			    IS_ON(flags, msgtypes[x].mt_type) &&
			    IS_ON(msgfacility[i].mf_msgtypes,
				  msgtypes[x].mt_type))
				(*msgfacility[i].mf_sendfunc)(&msgfacility[i],
							   msgtypes[x].mt_type,
							      flags,
							      mbuf);
}

/*
 * Front-end to _message()
 */
void
message(int lvl, const char *fmt, ...)
{
	static char buf[MSGBUFSIZ];
	va_list args;

	if (fmt != NULL) {
		va_start(args, fmt);
		(void) vsnprintf(buf, sizeof(buf), fmt, args);
		va_end(args);
	}

	_message(lvl, fmt ? buf : NULL);
}

/*
 * Display a debugging message
 */
static void
_debugmsg(int lvl, char *buf)
{
	if (IS_ON(debug, lvl))
		_message(MT_DEBUG, buf);
}

/*
 * Front-end to _debugmsg()
 */
void
debugmsg(int lvl, const char *fmt, ...)
{
	static char buf[MSGBUFSIZ];
	va_list args;

	va_start(args, fmt);
	(void) vsnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);

	_debugmsg(lvl, buf);
}

/*
 * Print an error message
 */
static void
_error(const char *msg)
{
	static char buf[MSGBUFSIZ];

	nerrs++;
	buf[0] = CNULL;

	if (msg) {
		if (isserver)
			(void) snprintf(buf, sizeof(buf),
					"REMOTE ERROR: %s", msg);
		else
			(void) snprintf(buf, sizeof(buf),
					"LOCAL ERROR: %s", msg);
	}

	_message(MT_NERROR, (buf[0]) ? buf : NULL);
}

/*
 * Frontend to _error()
 */
void
error(const char *fmt, ...)
{
	static char buf[MSGBUFSIZ];
	va_list args;

	buf[0] = CNULL;
	va_start(args, fmt);
	if (fmt)
		(void) vsnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);

	_error((buf[0]) ? buf : NULL);
}

/*
 * Display a fatal message
 */
static void
_fatalerr(const char *msg)
{
	static char buf[MSGBUFSIZ];

	++nerrs;

	if (isserver)
		(void) snprintf(buf, sizeof(buf), "REMOTE ERROR: %s", msg);
	else
		(void) snprintf(buf, sizeof(buf), "LOCAL ERROR: %s", msg);

	_message(MT_FERROR, buf);

	exit(nerrs);
}

/*
 * Front-end to _fatalerr()
 */
void
fatalerr(const char *fmt, ...)
{
	static char buf[MSGBUFSIZ];
	va_list args;

	va_start(args, fmt);
	(void) vsnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);

	_fatalerr(buf);
}

/*
 * Get the name of the file used for notify.
 * A side effect is that the file pointer to the file
 * is closed.  We assume this function is only called when
 * we are ready to read the file.
 */
char *
getnotifyfile(void)
{
	int i;

	for (i = 0; msgfacility[i].mf_name; i++)
		if (msgfacility[i].mf_msgfac == MF_NOTIFY &&
		    msgfacility[i].mf_fptr) {
			(void) fclose(msgfacility[i].mf_fptr);
			msgfacility[i].mf_fptr = NULL;
			return(msgfacility[i].mf_filename);
		}

	return(NULL);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: message.c,v 1.28 2016/03/30 20:51:59 millert Exp $ */
2
3			/*
4			* Copyright (c) 1983 Regents of the University of California.
5			* All rights reserved.
6			*
7			* Redistribution and use in source and binary forms, with or without
8			* modification, are permitted provided that the following conditions
9			* are met:
10			* 1. Redistributions of source code must retain the above copyright
11			* notice, this list of conditions and the following disclaimer.
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the distribution.
15			* 3. Neither the name of the University nor the names of its contributors
16			* may be used to endorse or promote products derived from this software
17			* without specific prior written permission.
18			*
19			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29			* SUCH DAMAGE.
30			*/
31
32			#include <errno.h>
33			#include <limits.h>
34			#include <paths.h>
35			#include <stdarg.h>
36			#include <stdio.h>
37			#include <stdlib.h>
38			#include <string.h>
39			#include <syslog.h>
40			#include <unistd.h>
41
42			#include "defs.h"
43
44			/*
45			* Message handling functions for both rdist and rdistd.
46			*/
47
48
49			#define MSGBUFSIZ 32*1024
50
51			int debug = 0; /* Debugging level */
52			int nerrs = 0; /* Number of errors */
53
54			/*
55			* Message Types
56			*/
57			struct msgtype {
58			int mt_type; /* Type (bit) */
59			char mt_name; / Name of message type */
60			} msgtypes[] = {
61			{ MT_CHANGE, "change" },
62			{ MT_INFO, "info" },
63			{ MT_NOTICE, "notice" },
64			{ MT_NERROR, "nerror" },
65			{ MT_FERROR, "ferror" },
66			{ MT_WARNING, "warning" },
67			{ MT_VERBOSE, "verbose" },
68			{ MT_ALL, "all" },
69			{ MT_DEBUG, "debug" },
70			{ 0 },
71			};
72
73			/*
74			* Description of message facilities
75			*/
76			struct msgfacility {
77			/* compile time initialized data */
78			int mf_msgfac; /* One of MF_* from below */
79			char mf_name; / Name of this facility */
80			void (mf_sendfunc) / Function to send msg */
81			(struct msgfacility , int, int, char );
82			/* run time initialized data */
83			int mf_msgtypes; /* Bitmask of MT_* from above*/
84			char mf_filename; / Name of file */
85			FILE mf_fptr; / File pointer to output to */
86			};
87
88			/*
89			* Message Facilities
90			*/
91			#define MF_STDOUT 1 /* Standard Output */
92			#define MF_NOTIFY 2 /* Notify mail service */
93			#define MF_FILE 3 /* A normal file */
94			#define MF_SYSLOG 4 /* syslog() */
95
96			static void msgsendstdout(struct msgfacility , int, int, char );
97			static void msgsendsyslog(struct msgfacility , int, int, char );
98			static void msgsendfile(struct msgfacility , int, int, char );
99			static void msgsendnotify(struct msgfacility , int, int, char );
100
101			/*
102			* Message Facilities
103			*/
104			struct msgfacility msgfacility[] = {
105			{ MF_STDOUT, "stdout", msgsendstdout },
106			{ MF_FILE, "file", msgsendfile },
107			{ MF_SYSLOG, "syslog", msgsendsyslog },
108			{ MF_NOTIFY, "notify", msgsendnotify },
109			{ 0 },
110			};
111
112			static struct msgfacility getmsgfac(char );
113			static struct msgtype getmsgtype(char );
114			static char setmsgtypes(struct msgfacility , char *);
115			static void _message(int, char *);
116			static void _debugmsg(int, char *);
117			static void _error(const char *);
118			static void _fatalerr(const char *);
119
120			/*
121			* Print message logging usage message
122			*/
123			void
124			msgprusage(void)
125			{
126			int i, x;
127
128			(void) fprintf(stderr, "\nWhere <msgopt> is of form\n");
129			(void) fprintf(stderr,
130			"\t<facility1>=<type1>,<type2>,...:<facility2>=<type1>,<type2>...\n");
131
132			(void) fprintf(stderr, "Valid <facility> names:");
133
134			for (i = 0; msgfacility[i].mf_name; ++i)
135			(void) fprintf(stderr, " %s", msgfacility[i].mf_name);
136
137			(void) fprintf(stderr, "\nValid <type> names:");
138			for (x = 0; msgtypes[x].mt_name; ++x)
139			(void) fprintf(stderr, " %s", msgtypes[x].mt_name);
140
141			(void) fprintf(stderr, "\n");
142			}
143
144			/*
145			* Print enabled message logging info
146			*/
147			void
148			msgprconfig(void)
149			{
150			int i, x;
151			static char buf[MSGBUFSIZ];
152
153			debugmsg(DM_MISC, "Current message logging config:");
154			for (i = 0; msgfacility[i].mf_name; ++i) {
155			(void) snprintf(buf, sizeof(buf), " %.*s=",
156			(int)(sizeof(buf) - 7), msgfacility[i].mf_name);
157			for (x = 0; msgtypes[x].mt_name; ++x)
158			if (IS_ON(msgfacility[i].mf_msgtypes,
159			msgtypes[x].mt_type)) {
160			if (x > 0)
161			(void) strlcat(buf, ",", sizeof(buf));
162			(void) strlcat(buf, msgtypes[x].mt_name,
163			sizeof(buf));
164			}
165			debugmsg(DM_MISC, "%s", buf);
166			}
167
168			}
169
170			/*
171			* Get the Message Facility entry "name"
172			*/
173			static struct msgfacility *
174			getmsgfac(char *name)
175			{
176			int i;
177
178			for (i = 0; msgfacility[i].mf_name; ++i)
179			if (strcasecmp(name, msgfacility[i].mf_name) == 0)
180			return(&msgfacility[i]);
181
182			return(NULL);
183			}
184
185			/*
186			* Get the Message Type entry named "name"
187			*/
188			static struct msgtype *
189			getmsgtype(char *name)
190			{
191			int i;
192
193			for (i = 0; msgtypes[i].mt_name; ++i)
194			if (strcasecmp(name, msgtypes[i].mt_name) == 0)
195			return(&msgtypes[i]);
196
197			return(NULL);
198			}
199
200			/*
201			* Set Message Type information for Message Facility "msgfac" as
202			* indicated by string "str".
203			*/
204			static char *
205			setmsgtypes(struct msgfacility msgfac, char str)
206			{
207			static char ebuf[BUFSIZ];
208			char *cp;
209			char strptr, word;
210			struct msgtype *mtp;
211
212			/*
213			* MF_SYSLOG is the only supported message facility for the server
214			*/
215			if (isserver && (msgfac->mf_msgfac != MF_SYSLOG &&
216			msgfac->mf_msgfac != MF_FILE)) {
217			(void) snprintf(ebuf, sizeof(ebuf),
218			"The \"%.*s\" message facility cannot be used by the server.",
219			100, msgfac->mf_name);
220			return(ebuf);
221			}
222
223			strptr = str;
224
225			/*
226			* Do any necessary Message Facility preparation
227			*/
228			switch(msgfac->mf_msgfac) {
229			case MF_FILE:
230			/*
231			* The MF_FILE string should look like "<file>=<types>".
232			*/
233			if ((cp = strchr(strptr, '=')) == NULL)
234			return(
235			"No file name found for \"file\" message facility");
236			*cp++ = CNULL;
237
238			if ((msgfac->mf_fptr = fopen(strptr, "w")) == NULL)
239			fatalerr("Cannot open log file for writing: %s: %s.",
240			strptr, SYSERR);
241			msgfac->mf_filename = xstrdup(strptr);
242
243			strptr = cp;
244			break;
245
246			case MF_NOTIFY:
247			break;
248
249			case MF_STDOUT:
250			msgfac->mf_fptr = stdout;
251			break;
252
253			case MF_SYSLOG:
254			openlog(progname, LOG_PID, LOG_DAEMON);
255			break;
256			}
257
258			/*
259			* Parse each type word
260			*/
261			msgfac->mf_msgtypes = 0; /* Start from scratch */
262			while (strptr) {
263			word = strptr;
264			if ((cp = strchr(strptr, ',')) != NULL)
265			*cp++ = CNULL;
266			strptr = cp;
267
268			if ((mtp = getmsgtype(word)) != NULL) {
269			msgfac->mf_msgtypes \|= mtp->mt_type;
270			/*
271			* XXX This is really a kludge until we add real
272			* control over debugging.
273			*/
274			if (!debug && isserver &&
275			strcasecmp(word, "debug") == 0)
276			debug = DM_ALL;
277			} else {
278			(void) snprintf(ebuf, sizeof(ebuf),
279			"Message type \"%.*s\" is invalid.",
280			100, word);
281			return(ebuf);
282			}
283			}
284
285			return(NULL);
286			}
287
288			/*
289			* Parse a message logging option string
290			*/
291			char *
292			msgparseopts(char *msgstr, int doset)
293			{
294			static char ebuf[BUFSIZ], msgbuf[MSGBUFSIZ];
295			char cp, optstr;
296			char *word;
297			struct msgfacility *msgfac;
298
299			if (msgstr == NULL)
300			return("NULL message string");
301
302			/* strtok() is harmful */
303			(void) strlcpy(msgbuf, msgstr, sizeof(msgbuf));
304
305			/*
306			* Each <facility>=<types> list is separated by ":".
307			*/
308			for (optstr = strtok(msgbuf, ":"); optstr;
309			optstr = strtok(NULL, ":")) {
310
311			if ((cp = strchr(optstr, '=')) == NULL)
312			return("No '=' found");
313
314			*cp++ = CNULL;
315			word = optstr;
316			if ((int)strlen(word) <= 0)
317			return("No message facility specified");
318			if ((int)strlen(cp) <= 0)
319			return("No message type specified");
320
321			if ((msgfac = getmsgfac(word)) == NULL) {
322			(void) snprintf(ebuf, sizeof(ebuf),
323			"%.*s is not a valid message facility",
324			100, word);
325			return(ebuf);
326			}
327
328			if (doset) {
329			char *mcp;
330
331			if ((mcp = setmsgtypes(msgfac, cp)) != NULL)
332			return(mcp);
333			}
334			}
335
336			if (isserver && debug) {
337			debugmsg(DM_MISC, "%s", getversion());
338			msgprconfig();
339			}
340
341			return(NULL);
342			}
343
344			/*
345			* Send a message to facility "stdout".
346			* For rdistd, this is really the rdist client.
347			*/
348			static void
349			msgsendstdout(struct msgfacility msgfac, int mtype, int flags, char msgbuf)
350			{
351			char cmd;
352
353			if (isserver) {
354			if (rem_w < 0 \|\| IS_ON(flags, MT_NOREMOTE))
355			return;
356
357			cmd = CNULL;
358
359			switch(mtype) {
360			case MT_NERROR: cmd = C_ERRMSG; break;
361			case MT_FERROR: cmd = C_FERRMSG; break;
362			case MT_NOTICE: cmd = C_NOTEMSG; break;
363			case MT_REMOTE: cmd = C_LOGMSG; break;
364			}
365
366			if (cmd != CNULL)
367			(void) sendcmd(cmd, "%s", msgbuf);
368			} else {
369			switch(mtype) {
370			case MT_FERROR:
371			case MT_NERROR:
372			if (msgbuf && *msgbuf) {
373			(void) fprintf(stderr, "%s\n", msgbuf);
374			(void) fflush(stderr);
375			}
376			break;
377
378			case MT_DEBUG:
379			/*
380			* Only things that are strictly MT_DEBUG should
381			* be shown.
382			*/
383			if (flags != MT_DEBUG)
384			return;
385			case MT_NOTICE:
386			case MT_CHANGE:
387			case MT_INFO:
388			case MT_VERBOSE:
389			case MT_WARNING:
390			if (msgbuf && *msgbuf) {
391			(void) printf("%s\n", msgbuf);
392			(void) fflush(stdout);
393			}
394			break;
395			}
396			}
397			}
398
399			/*
400			* Send a message to facility "syslog"
401			*/
402			static void
403			msgsendsyslog(struct msgfacility msgfac, int mtype, int flags, char msgbuf)
404			{
405			int syslvl = 0;
406
407			if (!msgbuf \|\| !*msgbuf)
408			return;
409
410			switch(mtype) {
411			#if defined(SL_NERROR)
412			case MT_NERROR: syslvl = SL_NERROR; break;
413			#endif
414			#if defined(SL_FERROR)
415			case MT_FERROR: syslvl = SL_FERROR; break;
416			#endif
417			#if defined(SL_WARNING)
418			case MT_WARNING: syslvl = SL_WARNING; break;
419			#endif
420			#if defined(SL_CHANGE)
421			case MT_CHANGE: syslvl = SL_CHANGE; break;
422			#endif
423			#if defined(SL_INFO)
424			case MT_SYSLOG:
425			case MT_VERBOSE:
426			case MT_INFO: syslvl = SL_INFO; break;
427			#endif
428			#if defined(SL_NOTICE)
429			case MT_NOTICE: syslvl = SL_NOTICE; break;
430			#endif
431			#if defined(SL_DEBUG)
432			case MT_DEBUG: syslvl = SL_DEBUG; break;
433			#endif
434			}
435
436			if (syslvl)
437			syslog(syslvl, "%s", msgbuf);
438			}
439
440			/*
441			* Send a message to a "file" facility.
442			*/
443			static void
444			msgsendfile(struct msgfacility msgfac, int mtype, int flags, char msgbuf)
445			{
446			if (msgfac->mf_fptr == NULL)
447			return;
448
449			if (!msgbuf \|\| !*msgbuf)
450			return;
451
452			(void) fprintf(msgfac->mf_fptr, "%s\n", msgbuf);
453			(void) fflush(msgfac->mf_fptr);
454			}
455
456			/*
457			* Same method as msgsendfile()
458			*/
459			static void
460			msgsendnotify(struct msgfacility msgfac, int mtype, int flags, char msgbuf)
461			{
462			char *tempfile;
463
464			if (IS_ON(flags, MT_DEBUG))
465			return;
466
467			if (!msgbuf \|\| !*msgbuf)
468			return;
469
470			if (!msgfac->mf_fptr) {
471			char *cp;
472			int fd;
473			size_t len;
474
475			/*
476			* Create and open a new temporary file
477			*/
478			if ((cp = getenv("TMPDIR")) == NULL \|\| *cp == '\0')
479			cp = _PATH_TMP;
480			len = strlen(cp) + 1 + sizeof(_RDIST_TMP);
481			tempfile = xmalloc(len);
482			(void) snprintf(tempfile, len, "%s/%s", cp, _RDIST_TMP);
483
484			msgfac->mf_filename = tempfile;
485			if ((fd = mkstemp(msgfac->mf_filename)) < 0 \|\|
486			(msgfac->mf_fptr = fdopen(fd, "w")) == NULL)
487			fatalerr("Cannot open notify file for writing: %s: %s.",
488			msgfac->mf_filename, SYSERR);
489			debugmsg(DM_MISC, "Created notify temp file '%s'",
490			msgfac->mf_filename);
491			}
492
493			if (msgfac->mf_fptr == NULL)
494			return;
495
496			(void) fprintf(msgfac->mf_fptr, "%s\n", msgbuf);
497			(void) fflush(msgfac->mf_fptr);
498			}
499
500			/*
501			* Insure currenthost is set to something reasonable.
502			*/
503			void
504			checkhostname(void)
505			{
506			static char mbuf[HOST_NAME_MAX+1];
507			char *cp;
508
509			if (!currenthost) {
510			if (gethostname(mbuf, sizeof(mbuf)) == 0) {
511			if ((cp = strchr(mbuf, '.')) != NULL)
512			*cp = CNULL;
513			currenthost = xstrdup(mbuf);
514			} else
515			currenthost = "(unknown)";
516			}
517			}
518
519			/*
520			* Print a message contained in "msgbuf" if a level "lvl" is set.
521			*/
522			static void
523			_message(int flags, char *msgbuf)
524			{
525			int i, x;
526			static char mbuf[2048];
527
528			if (msgbuf && *msgbuf) {
529			/*
530			* Ensure no stray newlines are present
531			*/
532			msgbuf[strcspn(msgbuf, "\n")] = CNULL;
533
534			checkhostname();
535			if (strncmp(currenthost, msgbuf, strlen(currenthost)) == 0)
536			(void) strlcpy(mbuf, msgbuf, sizeof(mbuf));
537			else
538			(void) snprintf(mbuf, sizeof(mbuf),
539			"%s: %s", currenthost, msgbuf);
540			} else
541			mbuf[0] = '\0';
542
543			/*
544			* Special case for messages that only get
545			* logged to the system log facility
546			*/
547			if (IS_ON(flags, MT_SYSLOG)) {
548			msgsendsyslog(NULL, MT_SYSLOG, flags, mbuf);
549			return;
550			}
551
552			/*
553			* Special cases
554			*/
555			if (isserver && IS_ON(flags, MT_NOTICE)) {
556			msgsendstdout(NULL, MT_NOTICE, flags, mbuf);
557			return;
558			} else if (isserver && IS_ON(flags, MT_REMOTE))
559			msgsendstdout(NULL, MT_REMOTE, flags, mbuf);
560			else if (isserver && IS_ON(flags, MT_NERROR))
561			msgsendstdout(NULL, MT_NERROR, flags, mbuf);
562			else if (isserver && IS_ON(flags, MT_FERROR))
563			msgsendstdout(NULL, MT_FERROR, flags, mbuf);
564
565			/*
566			* For each Message Facility, check each Message Type to see
567			* if the bits in "flags" are set. If so, call the appropriate
568			* Message Facility to dispatch the message.
569			*/
570			for (i = 0; msgfacility[i].mf_name; ++i)
571			for (x = 0; msgtypes[x].mt_name; ++x)
572			/*
573			* XXX MT_ALL should not be used directly
574			*/
575			if (msgtypes[x].mt_type != MT_ALL &&
576			IS_ON(flags, msgtypes[x].mt_type) &&
577			IS_ON(msgfacility[i].mf_msgtypes,
578			msgtypes[x].mt_type))
579			(*msgfacility[i].mf_sendfunc)(&msgfacility[i],
580			msgtypes[x].mt_type,
581			flags,
582			mbuf);
583			}
584
585			/*
586			* Front-end to _message()
587			*/
588			void
589			message(int lvl, const char *fmt, ...)
590			{
591			static char buf[MSGBUFSIZ];
592			va_list args;
593
594			if (fmt != NULL) {
595			va_start(args, fmt);
596			(void) vsnprintf(buf, sizeof(buf), fmt, args);
597			va_end(args);
598			}
599
600			_message(lvl, fmt ? buf : NULL);
601			}
602
603			/*
604			* Display a debugging message
605			*/
606			static void
607			_debugmsg(int lvl, char *buf)
608			{
609			if (IS_ON(debug, lvl))
610			_message(MT_DEBUG, buf);
611			}
612
613			/*
614			* Front-end to _debugmsg()
615			*/
616			void
617			debugmsg(int lvl, const char *fmt, ...)
618			{
619			static char buf[MSGBUFSIZ];
620			va_list args;
621
622			va_start(args, fmt);
623			(void) vsnprintf(buf, sizeof(buf), fmt, args);
624			va_end(args);
625
626			_debugmsg(lvl, buf);
627			}
628
629			/*
630			* Print an error message
631			*/
632			static void
633			_error(const char *msg)
634			{
635			static char buf[MSGBUFSIZ];
636
637			nerrs++;
638			buf[0] = CNULL;
639
640			if (msg) {
641			if (isserver)
642			(void) snprintf(buf, sizeof(buf),
643			"REMOTE ERROR: %s", msg);
644			else
645			(void) snprintf(buf, sizeof(buf),
646			"LOCAL ERROR: %s", msg);
647			}
648
649			_message(MT_NERROR, (buf[0]) ? buf : NULL);
650			}
651
652			/*
653			* Frontend to _error()
654			*/
655			void
656			error(const char *fmt, ...)
657			{
658			static char buf[MSGBUFSIZ];
659			va_list args;
660
661			buf[0] = CNULL;
662			va_start(args, fmt);
663			if (fmt)
664			(void) vsnprintf(buf, sizeof(buf), fmt, args);
665			va_end(args);
666
667			_error((buf[0]) ? buf : NULL);
668			}
669
670			/*
671			* Display a fatal message
672			*/
673			static void
674			_fatalerr(const char *msg)
675			{
676			static char buf[MSGBUFSIZ];
677
678			++nerrs;
679
680			if (isserver)
681			(void) snprintf(buf, sizeof(buf), "REMOTE ERROR: %s", msg);
682			else
683			(void) snprintf(buf, sizeof(buf), "LOCAL ERROR: %s", msg);
684
685			_message(MT_FERROR, buf);
686
687			exit(nerrs);
688			}
689
690			/*
691			* Front-end to _fatalerr()
692			*/
693			void
694			fatalerr(const char *fmt, ...)
695			{
696			static char buf[MSGBUFSIZ];
697			va_list args;
698
699			va_start(args, fmt);
700			(void) vsnprintf(buf, sizeof(buf), fmt, args);
701			va_end(args);
702
703			_fatalerr(buf);
704			}
705
706			/*
707			* Get the name of the file used for notify.
708			* A side effect is that the file pointer to the file
709			* is closed. We assume this function is only called when
710			* we are ready to read the file.
711			*/
712			char *
713			getnotifyfile(void)
714			{
715			int i;
716
717			for (i = 0; msgfacility[i].mf_name; i++)
718			if (msgfacility[i].mf_msgfac == MF_NOTIFY &&
719			msgfacility[i].mf_fptr) {
720			(void) fclose(msgfacility[i].mf_fptr);
721			msgfacility[i].mf_fptr = NULL;
722			return(msgfacility[i].mf_filename);
723			}
724
725			return(NULL);
726			}