/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
 *
 * logadm/err.c -- some basic error routines
 *
 */

#include <stdio.h>
#include <unistd.h>
#include <libintl.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include "err.h"

jmp_buf Err_env;
jmp_buf	*Err_env_ptr;
static const char *Myname;
static int Exitcode;
static FILE *Errorfile;

/*
 * err_init -- initialize the error handling routine
 *
 */
void
err_init(const char *myname)
{
	char *ptr;

	if ((ptr = strrchr(myname, '/')) == NULL)
		Myname = myname;
	else
		Myname = ptr + 1;
}

static const char *File;
static int Line;

/*
 * err_fileline -- record the filename/line number for err(EF_FILE, ...)
 */
void
err_fileline(const char *file, int line)
{
	File = file;
	Line = line;
}

/*
 * err -- print an error message and return, exit or longjmp based on flags
 *
 * this routine calls gettext() to translate the fmt string.
 */
/*PRINTFLIKE2*/
void
err(int flags, const char *fmt, ...)
{
	va_list ap;
	int safe_errno = errno;
	char *errno_msg = NULL;
	int as_is = 0;
	int jump = 0;
	int warning = 0;
	int fileline = 0;
	char *prefix = "Error: ";
	const char *intlfmt;

	va_start(ap, fmt);
	intlfmt = gettext(fmt);

	if (flags & EF_WARN) {
		warning = 1;
		prefix = "Warning: ";
	}
	if (flags & EF_FILE) {
		fileline = 1;
		Exitcode++;
	}
	if (flags & EF_SYS)
		errno_msg = strerror(safe_errno);
	if (flags & EF_JMP)
		jump = 1;
	if (flags & EF_RAW)
		as_is = 1;

	/* print a copy to stderr */
	if (!as_is) {
		if (Myname != NULL) {
			(void) fprintf(stderr, "%s: ", Myname);
			if (Errorfile)
				(void) fprintf(Errorfile, "%s: ", Myname);
		}
		if (fileline && File) {
			(void) fprintf(stderr, "%s line %d: ", File, Line);
			if (Errorfile)
				(void) fprintf(Errorfile,
				    "%s line %d: ", File, Line);
		}
		(void) fputs(gettext(prefix), stderr);
		if (Errorfile)
			(void) fputs(gettext(prefix), Errorfile);
	}
	(void) vfprintf(stderr, intlfmt, ap);
	if (Errorfile)
		(void) vfprintf(Errorfile, intlfmt, ap);
	if (errno_msg != NULL) {
		(void) fprintf(stderr, ": %s", errno_msg);
		if (Errorfile)
			(void) fprintf(Errorfile, ": %s", errno_msg);
	}
	if (!as_is) {
		(void) fprintf(stderr, "\n");
		if (Errorfile)
			(void) fprintf(Errorfile, "\n");
	}
	(void) fflush(stderr);
	if (Errorfile)
		(void) fflush(Errorfile);

	va_end(ap);

	if (jump)
		longjmp(*Err_env_ptr, 1);

	if (!warning && !fileline) {
		err_done(1);
		/*NOTREACHED*/
	}
}

/*
 * out -- print a message and return
 *
 * this routine calls gettext() to translate the fmt string.
 */
/*PRINTFLIKE1*/
void
out(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);

	(void) vfprintf(stdout, gettext(fmt), ap);

	va_end(ap);
}

#define	CHUNKSIZE 8192		/* for copying stderr */
/*
 * err_fromfd -- copy data from fd to stderr
 */
void
err_fromfd(int fd)
{
	char buf[CHUNKSIZE];
	int count;

	while ((count = read(fd, buf, CHUNKSIZE)) > 0) {
		(void) fwrite(buf, 1, count, stderr);
		if (Errorfile)
			(void) fwrite(buf, 1, count, Errorfile);
	}
	(void) fflush(stderr);
	if (Errorfile)
		(void) fflush(Errorfile);
}

/*
 * err_done -- exit the program
 */
void
err_done(int exitcode)
{
	/* send error mail if applicable */
	err_mailto(NULL);

	if (exitcode)
		exit(exitcode);
	else
		exit(Exitcode);
	/*NOTREACHED*/
}

#define	MAXLINE	8192	/* for tmp file line buffer */
/*
 * err_mailto -- arrange for error output to be mailed to someone
 */
void
err_mailto(const char *recipient)
{
	static const char *lastrecipient;
	static char mailcmd[] = "/bin/mailx -s 'logadm error output'";
	char *cmd;
	int len;
	FILE *pfp;
	char line[MAXLINE];

	if (lastrecipient != NULL) {
		if (recipient != NULL &&
		    strcmp(recipient, lastrecipient) == 0)
			return;		/* keep going, same recipient */

		/* stop saving output for lastrecipient and send message */
		if (ftell(Errorfile)) {
			rewind(Errorfile);
			len = strlen(lastrecipient) + strlen(mailcmd) + 2;
			cmd = MALLOC(len);
			(void) snprintf(cmd, len, "%s %s",
			    mailcmd, lastrecipient);
			if ((pfp = popen(cmd, "w")) == NULL)
				err(EF_SYS, "popen to mailx");
			while (fgets(line, MAXLINE, Errorfile) != NULL)
				(void) fputs(line, pfp);
			(void) pclose(pfp);
		}
		(void) fclose(Errorfile);
		Errorfile = NULL;
	}

	if (recipient != NULL) {
		/* start saving error output for this recipient */
		if ((Errorfile = tmpfile()) == NULL)
			err(EF_SYS, "tmpfile");
	}
	lastrecipient = recipient;
}

/*
 * err_malloc -- a malloc() with checks
 *
 * this routine is typically called via the MALLOC() macro in err.h
 */
void *
err_malloc(int nbytes, const char *fname, int line)
{
	void *retval = malloc(nbytes);

	if (retval == NULL)
		err(0, "%s:%d: out of memory", fname, line);

	return (retval);
}

/*
 * err_realloc -- a realloc() with checks
 *
 * this routine is typically called via the REALLOC() macro in err.h
 */
void *
err_realloc(void *ptr, int nbytes, const char *fname, int line)
{
	void *retval = realloc(ptr, nbytes);

	if (retval == NULL)
		err(0, "%s:%d: out of memory", fname, line);

	return (retval);
}

/*
 * err_strdup -- a strdup() with checks
 *
 * this routine is typically called via the STRDUP() macro in err.h
 */
char *
err_strdup(const char *ptr, const char *fname, int line)
{
	char *retval = NULL;

	if (ptr != NULL) {
		retval = strdup(ptr);
		if (retval == NULL)
			err(0, "%s:%d: out of memory", fname, line);
	} else
		err(0, "%s:%d: could not strdup", fname, line);


	return (retval);

}

/*
 * err_free -- a free() with checks
 *
 * this routine is typically called via the FREE() macro in err.h
 */
/*ARGSUSED1*/
void
err_free(void *ptr, const char *fname, int line)
{
	/* nothing to check in this version */
	free(ptr);
}

/*
 * err_exitcode -- set an error exit code for when done(0) is called
 */
void
err_exitcode(int exitcode)
{
	Exitcode = exitcode;
}