embedaddon/sudo/plugins/sudoers/visudo.c - diff

Return to visudo.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / plugins / sudoers

Diff for /embedaddon/sudo/plugins/sudoers/visudo.c between versions 1.1 and 1.1.1.5

version 1.1, 2012/02/21 16:23:02	version 1.1.1.5, 2013/10/14 07:56:35
Line 1	Line 1
/*	/*
* Copyright (c) 1996, 1998-2005, 2007-2011	* Copyright (c) 1996, 1998-2005, 2007-2013
* Todd C. Miller <Todd.Miller@courtesan.com>	* Todd C. Miller <Todd.Miller@courtesan.com>
*	*
* Permission to use, copy, modify, and distribute this software for any	* Permission to use, copy, modify, and distribute this software for any
Line 32	Line 32
#include <config.h>	#include <config.h>

#include <sys/types.h>	#include <sys/types.h>
#include <sys/param.h>
#include <sys/stat.h>	#include <sys/stat.h>
#include <sys/socket.h>	#include <sys/socket.h>
#include <sys/time.h>	#include <sys/time.h>
	#include <sys/uio.h>
#ifndef __TANDEM	#ifndef __TANDEM
# include <sys/file.h>	# include <sys/file.h>
#endif	#endif
Line 67	Line 67
#include <fcntl.h>	#include <fcntl.h>
#include <netinet/in.h>	#include <netinet/in.h>
#include <arpa/inet.h>	#include <arpa/inet.h>
#include <netdb.h>
#if TIME_WITH_SYS_TIME	#if TIME_WITH_SYS_TIME
# include <time.h>	# include <time.h>
#endif	#endif
#ifdef HAVE_SETLOCALE	#ifdef HAVE_GETOPT_LONG
# include <locale.h>	# include <getopt.h>
#endif	# else
	# include "compat/getopt.h"
	#endif /* HAVE_GETOPT_LONG */

#include "sudoers.h"	#include "sudoers.h"
#include "interfaces.h"
#include "parse.h"	#include "parse.h"
#include "redblack.h"	#include "redblack.h"
#include "gettext.h"	#include "gettext.h"
#include "sudoers_version.h"	#include "sudoers_version.h"
	#include "sudo_conf.h"
#include <gram.h>	#include <gram.h>

struct sudoersfile {	struct sudoersfile {
Line 100 static void quit(int);	Line 101 static void quit(int);
static char get_args(char );	static char get_args(char );
static char get_editor(char *);	static char get_editor(char *);
static void get_hostname(void);	static void get_hostname(void);
static char whatnow(void);	static int whatnow(void);
static int check_aliases(int, int);	static int check_aliases(bool, bool);
static int check_syntax(char *, int, int);	static bool check_syntax(char *, bool, bool, bool);
static int edit_sudoers(struct sudoersfile , char , char *, int);	static bool edit_sudoers(struct sudoersfile , char , char *, int);
static int install_sudoers(struct sudoersfile *, int);	static bool install_sudoers(struct sudoersfile *, bool);
static int print_unused(void , void );	static int print_unused(void , void );
static int reparse_sudoers(char , char , int, int);	static bool reparse_sudoers(char , char , bool, bool);
static int run_command(char , char *);	static int run_command(char , char *);
static int visudo_printf(int msg_type, const char *fmt, ...);
static void setup_signals(void);	static void setup_signals(void);
static void help(void) __attribute__((__noreturn__));	static void help(void) __attribute__((__noreturn__));
static void usage(int);	static void usage(int);
	static void visudo_cleanup(void);

void cleanup(int);	extern void sudoerserror(const char *);
	extern void sudoersrestart(FILE *);

extern void yyerror(const char *);
extern void yyrestart(FILE *);

/*	/*
* External globals exported by the parser	* External globals exported by the parser
*/	*/
extern struct rbtree *aliases;	extern struct rbtree *aliases;
extern FILE *yyin;	extern FILE *sudoersin;
extern char sudoers, errorfile;	extern char sudoers, errorfile;
extern int errorlineno, parse_error;	extern int errorlineno;
/* For getopt(3) */	extern bool parse_error;
extern char *optarg;
extern int optind;

/*	/*
* Globals	* Globals
*/	*/
struct interface *interfaces;
struct sudo_user sudo_user;	struct sudo_user sudo_user;
struct passwd *list_pw;	struct passwd *list_pw;
sudo_printf_t sudo_printf = visudo_printf;
static struct sudoersfile_list sudoerslist;	static struct sudoersfile_list sudoerslist;
static struct rbtree *alias_freelist;	static struct rbtree *alias_freelist;
	static bool checkonly;
	static const char short_opts[] = "cf:hqsV";
	static struct option long_opts[] = {
	{ "check", no_argument, NULL, 'c' },
	{ "file", required_argument, NULL, 'f' },
	{ "help", no_argument, NULL, 'h' },
	{ "quiet", no_argument, NULL, 'q' },
	{ "strict", no_argument, NULL, 's' },
	{ "version", no_argument, NULL, 'V' },
	{ NULL, no_argument, NULL, '\0' },
	};

	__dso_public int main(int argc, char *argv[]);

int	int
main(int argc, char *argv[])	main(int argc, char *argv[])
{	{
struct sudoersfile *sp;	struct sudoersfile *sp;
char args, editor, *sudoers_path;	char args, editor, *sudoers_path;
int ch, checkonly, quiet, strict, oldperms;	int ch, exitcode = 0;
	bool quiet, strict, oldperms;
	debug_decl(main, SUDO_DEBUG_MAIN)

#if defined(SUDO_DEVEL) && defined(__OpenBSD__)	#if defined(SUDO_DEVEL) && defined(__OpenBSD__)
extern char *malloc_options;	{
malloc_options = "AFGJPR";	extern char *malloc_options;
	malloc_options = "AFGJPR";
	}
#endif	#endif

#if !defined(HAVE_GETPROGNAME) && !defined(HAVE___PROGNAME)	#if !defined(HAVE_GETPROGNAME) && !defined(HAVE___PROGNAME)
setprogname(argc > 0 ? argv[0] : "visudo");	setprogname(argc > 0 ? argv[0] : "visudo");
#endif	#endif

#ifdef HAVE_SETLOCALE	sudoers_setlocale(SUDOERS_LOCALE_USER, NULL);
setlocale(LC_ALL, "");
#endif
bindtextdomain("sudoers", LOCALEDIR); /* XXX - should have visudo domain */	bindtextdomain("sudoers", LOCALEDIR); /* XXX - should have visudo domain */
textdomain("sudoers");	textdomain("sudoers");

if (argc < 1)	if (argc < 1)
usage(1);	usage(1);

	/* Register fatal/fatalx callback. */
	fatal_callback_register(visudo_cleanup);

	/* Read sudo.conf. */
	sudo_conf_read(NULL);

/*	/*
* Arg handling.	* Arg handling.
*/	*/
checkonly = oldperms = quiet = strict = FALSE;	checkonly = oldperms = quiet = strict = false;
sudoers_path = _PATH_SUDOERS;	sudoers_path = _PATH_SUDOERS;
while ((ch = getopt(argc, argv, "Vcf:sq")) != -1) {	while ((ch = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {
switch (ch) {	switch (ch) {
case 'V':	case 'V':
(void) printf(_("%s version %s\n"), getprogname(), PACKAGE_VERSION);	(void) printf(_("%s version %s\n"), getprogname(),
(void) printf(_("%s grammar version %d\n"), getprogname(), SUDOERS_GRAMMAR_VERSION);	PACKAGE_VERSION);
exit(0);	(void) printf(_("%s grammar version %d\n"), getprogname(),
	SUDOERS_GRAMMAR_VERSION);
	goto done;
case 'c':	case 'c':
checkonly++; /* check mode */	checkonly = true; /* check mode */
break;	break;
case 'f':	case 'f':
sudoers_path = optarg; /* sudoers file path */	sudoers_path = optarg; /* sudoers file path */
oldperms = TRUE;	oldperms = true;
break;	break;
case 'h':	case 'h':
help();	help();
break;	break;
case 's':	case 's':
strict++; /* strict mode */	strict = true; /* strict mode */
break;	break;
case 'q':	case 'q':
quiet++; /* quiet mode */	quiet = true; /* quiet mode */
break;	break;
default:	default:
usage(1);	usage(1);
}	}
}	}
argc -= optind;	/* There should be no other command line arguments. */
argv += optind;	if (argc - optind != 0)
if (argc)
usage(1);	usage(1);

sudo_setpwent();	sudo_setpwent();
Line 205 main(int argc, char *argv[])	Line 223 main(int argc, char *argv[])
/* Mock up a fake sudo_user struct. */	/* Mock up a fake sudo_user struct. */
user_cmnd = "";	user_cmnd = "";
if ((sudo_user.pw = sudo_getpwuid(getuid())) == NULL)	if ((sudo_user.pw = sudo_getpwuid(getuid())) == NULL)
errorx(1, _("you do not exist in the %s database"), "passwd");	fatalx(_("you do not exist in the %s database"), "passwd");
get_hostname();	get_hostname();

/* Setup defaults data structures. */	/* Setup defaults data structures. */
init_defaults();	init_defaults();

if (checkonly)	if (checkonly) {
exit(check_syntax(sudoers_path, quiet, strict));	exitcode = check_syntax(sudoers_path, quiet, strict, oldperms) ? 0 : 1;
	goto done;
	}

/*	/*
* Parse the existing sudoers file(s) in quiet mode to highlight any	* Parse the existing sudoers file(s) to highlight any existing
* existing errors and to pull in editor and env_editor conf values.	* errors and to pull in editor and env_editor conf values.
*/	*/
if ((yyin = open_sudoers(sudoers_path, TRUE, NULL)) == NULL) {	if ((sudoersin = open_sudoers(sudoers_path, true, NULL)) == NULL)
error(1, "%s", sudoers_path);	exit(1);
}	init_parser(sudoers_path, false);
init_parser(sudoers_path, 0);	sudoersparse();
yyparse();
(void) update_defaults(SETDEF_GENERIC\|SETDEF_HOST\|SETDEF_USER);	(void) update_defaults(SETDEF_GENERIC\|SETDEF_HOST\|SETDEF_USER);

editor = get_editor(&args);	editor = get_editor(&args);
Line 242 main(int argc, char *argv[])	Line 261 main(int argc, char *argv[])
edit_sudoers(sp, editor, args, -1);	edit_sudoers(sp, editor, args, -1);
}	}

/* Check edited files for a parse error and re-edit any that fail. */	/*
reparse_sudoers(editor, args, strict, quiet);	* Check edited files for a parse error, re-edit any that fail
	* and install the edited files as needed.
/* Install the sudoers temp files. */	*/
tq_foreach_fwd(&sudoerslist, sp) {	if (reparse_sudoers(editor, args, strict, quiet)) {
if (!sp->modified)	tq_foreach_fwd(&sudoerslist, sp) {
(void) unlink(sp->tpath);
else
(void) install_sudoers(sp, oldperms);	(void) install_sudoers(sp, oldperms);
	}
}	}

exit(0);	done:
	sudo_debug_exit_int(__func__, __FILE__, __LINE__, sudo_debug_subsys, exitcode);
	exit(exitcode);
}	}

/*	/*
Line 282 static char *lineno_editors[] = {	Line 302 static char *lineno_editors[] = {

/*	/*
* Edit each sudoers file.	* Edit each sudoers file.
* Returns TRUE on success, else FALSE.	* Returns true on success, else false.
*/	*/
static int	static bool
edit_sudoers(struct sudoersfile sp, char editor, char *args, int lineno)	edit_sudoers(struct sudoersfile sp, char editor, char *args, int lineno)
{	{
int tfd; /* sudoers temp file descriptor */	int tfd; /* sudoers temp file descriptor */
int modified; /* was the file modified? */	bool modified; /* was the file modified? */
int ac; /* argument count */	int ac; /* argument count */
char *av; / argument vector for run_command */	char *av; / argument vector for run_command */
char cp; / scratch char pointer */	char cp; / scratch char pointer */
Line 299 edit_sudoers(struct sudoersfile sp, char editor, cha	Line 319 edit_sudoers(struct sudoersfile sp, char editor, cha
off_t orig_size; /* starting size of sudoers file */	off_t orig_size; /* starting size of sudoers file */
ssize_t nread; /* number of bytes read */	ssize_t nread; /* number of bytes read */
struct stat sb; /* stat buffer */	struct stat sb; /* stat buffer */
	bool rval = false; /* return value */
	debug_decl(edit_sudoers, SUDO_DEBUG_UTIL)

if (fstat(sp->fd, &sb) == -1)	if (fstat(sp->fd, &sb) == -1)
error(1, _("unable to stat %s"), sp->path);	fatal(_("unable to stat %s"), sp->path);
orig_size = sb.st_size;	orig_size = sb.st_size;
mtim_get(&sb, &orig_mtim);	mtim_get(&sb, &orig_mtim);

Line 310 edit_sudoers(struct sudoersfile sp, char editor, cha	Line 332 edit_sudoers(struct sudoersfile sp, char editor, cha
easprintf(&sp->tpath, "%s.tmp", sp->path);	easprintf(&sp->tpath, "%s.tmp", sp->path);
tfd = open(sp->tpath, O_WRONLY \| O_CREAT \| O_TRUNC, 0600);	tfd = open(sp->tpath, O_WRONLY \| O_CREAT \| O_TRUNC, 0600);
if (tfd < 0)	if (tfd < 0)
error(1, "%s", sp->tpath);	fatal("%s", sp->tpath);

/* Copy sp->path -> sp->tpath and reset the mtime. */	/* Copy sp->path -> sp->tpath and reset the mtime. */
if (orig_size != 0) {	if (orig_size != 0) {
(void) lseek(sp->fd, (off_t)0, SEEK_SET);	(void) lseek(sp->fd, (off_t)0, SEEK_SET);
while ((nread = read(sp->fd, buf, sizeof(buf))) > 0)	while ((nread = read(sp->fd, buf, sizeof(buf))) > 0)
if (write(tfd, buf, nread) != nread)	if (write(tfd, buf, nread) != nread)
error(1, _("write error"));	fatal(_("write error"));

/* Add missing newline at EOF if needed. */	/* Add missing newline at EOF if needed. */
if (nread > 0 && buf[nread - 1] != '\n') {	if (nread > 0 && buf[nread - 1] != '\n') {
buf[0] = '\n';	buf[0] = '\n';
if (write(tfd, buf, 1) != 1)	if (write(tfd, buf, 1) != 1)
error(1, _("write error"));	fatal(_("write error"));
}	}
}	}
(void) close(tfd);	(void) close(tfd);
Line 361 edit_sudoers(struct sudoersfile sp, char editor, cha	Line 383 edit_sudoers(struct sudoersfile sp, char editor, cha
/* Find the length of the argument vector */	/* Find the length of the argument vector */
ac = 3 + (lineno > 0);	ac = 3 + (lineno > 0);
if (args) {	if (args) {
int wasblank;	bool wasblank;

ac++;	ac++;
for (wasblank = FALSE, cp = args; *cp; cp++) {	for (wasblank = false, cp = args; *cp; cp++) {
if (isblank((unsigned char) *cp))	if (isblank((unsigned char) *cp))
wasblank = TRUE;	wasblank = true;
else if (wasblank) {	else if (wasblank) {
wasblank = FALSE;	wasblank = false;
ac++;	ac++;
}	}
}	}
Line 407 edit_sudoers(struct sudoersfile sp, char editor, cha	Line 429 edit_sudoers(struct sudoersfile sp, char editor, cha
if (stat(sp->tpath, &sb) < 0) {	if (stat(sp->tpath, &sb) < 0) {
warningx(_("unable to stat temporary file (%s), %s unchanged"),	warningx(_("unable to stat temporary file (%s), %s unchanged"),
sp->tpath, sp->path);	sp->tpath, sp->path);
return FALSE;	goto done;
}	}
if (sb.st_size == 0 && orig_size != 0) {	if (sb.st_size == 0 && orig_size != 0) {
warningx(_("zero length temporary file (%s), %s unchanged"),	warningx(_("zero length temporary file (%s), %s unchanged"),
sp->tpath, sp->path);	sp->tpath, sp->path);
sp->modified = TRUE;	sp->modified = true;
return FALSE;	goto done;
}	}
} else {	} else {
warningx(_("editor (%s) failed, %s unchanged"), editor, sp->path);	warningx(_("editor (%s) failed, %s unchanged"), editor, sp->path);
return FALSE;	goto done;
}	}

/* Set modified bit if use changed the file. */	/* Set modified bit if use changed the file. */
modified = TRUE;	modified = true;
mtim_get(&sb, &tv);	mtim_get(&sb, &tv);
if (orig_size == sb.st_size && timevalcmp(&orig_mtim, &tv, ==)) {	if (orig_size == sb.st_size && timevalcmp(&orig_mtim, &tv, ==)) {
/*	/*
Line 430 edit_sudoers(struct sudoersfile sp, char editor, cha	Line 452 edit_sudoers(struct sudoersfile sp, char editor, cha
*/	*/
timevalsub(&tv1, &tv2);	timevalsub(&tv1, &tv2);
if (timevalisset(&tv2))	if (timevalisset(&tv2))
modified = FALSE;	modified = false;
}	}

/*	/*
Line 441 edit_sudoers(struct sudoersfile sp, char editor, cha	Line 463 edit_sudoers(struct sudoersfile sp, char editor, cha
else	else
warningx(_("%s unchanged"), sp->tpath);	warningx(_("%s unchanged"), sp->tpath);

return TRUE;	rval = true;
	done:
	debug_return_bool(rval);
}	}

/*	/*
* Parse sudoers after editing and re-edit any ones that caused a parse error.	* Parse sudoers after editing and re-edit any ones that caused a parse error.
* Returns TRUE on success, else FALSE.
*/	*/
static int	static bool
reparse_sudoers(char editor, char args, int strict, int quiet)	reparse_sudoers(char editor, char args, bool strict, bool quiet)
{	{
struct sudoersfile sp, last;	struct sudoersfile sp, last;
FILE *fp;	FILE *fp;
int ch;	int ch;
	debug_decl(reparse_sudoers, SUDO_DEBUG_UTIL)

/*	/*
* Parse the edited sudoers files and do sanity checking	* Parse the edited sudoers files and do sanity checking
*/	*/
do {	while ((sp = tq_first(&sudoerslist)) != NULL) {
sp = tq_first(&sudoerslist);
last = tq_last(&sudoerslist);	last = tq_last(&sudoerslist);
fp = fopen(sp->tpath, "r+");	fp = fopen(sp->tpath, "r+");
if (fp == NULL)	if (fp == NULL)
errorx(1, _("unable to re-open temporary file (%s), %s unchanged."),	fatalx(_("unable to re-open temporary file (%s), %s unchanged."),
sp->tpath, sp->path);	sp->tpath, sp->path);

/* Clean slate for each parse */	/* Clean slate for each parse */
init_defaults();	init_defaults();
init_parser(sp->path, quiet);	init_parser(sp->path, quiet);

/* Parse the sudoers temp file */	/* Parse the sudoers temp file(s) */
yyrestart(fp);	sudoersrestart(fp);
if (yyparse() && !parse_error) {	if (sudoersparse() && !parse_error) {
warningx(_("unabled to parse temporary file (%s), unknown error"),	warningx(_("unabled to parse temporary file (%s), unknown error"),
sp->tpath);	sp->tpath);
parse_error = TRUE;	parse_error = true;
errorfile = sp->path;	errorfile = sp->path;
}	}
fclose(yyin);	fclose(sudoersin);
if (!parse_error) {	if (!parse_error) {
if (!update_defaults(SETDEF_GENERIC\|SETDEF_HOST\|SETDEF_USER) \|\|	if (!check_defaults(SETDEF_ALL, quiet) \|\|
check_aliases(strict, quiet) != 0) {	check_aliases(strict, quiet) != 0) {
parse_error = TRUE;	parse_error = true;
errorfile = sp->path;	errorfile = NULL;
}	}
}	}

/*	/*
* Got an error, prompt the user for what to do now	* Got an error, prompt the user for what to do now.
*/	*/
if (parse_error) {	if (parse_error) {
switch (whatnow()) {	switch (whatnow()) {
case 'Q' : parse_error = FALSE; /* ignore parse error */	case 'Q':
break;	parse_error = false; /* ignore parse error */
case 'x' : cleanup(0);	break;
exit(0);	case 'x':
break;	visudo_cleanup(); /* discard changes */
}	debug_return_bool(false);
}	case 'e':
if (parse_error) {	default:
/* Edit file with the parse error */	/* Edit file with the parse error */
tq_foreach_fwd(&sudoerslist, sp) {	tq_foreach_fwd(&sudoerslist, sp) {
if (errorfile == NULL \|\| strcmp(sp->path, errorfile) == 0) {	if (errorfile == NULL \|\| strcmp(sp->path, errorfile) == 0) {
edit_sudoers(sp, editor, args, errorlineno);	edit_sudoers(sp, editor, args, errorlineno);
break;	if (errorfile != NULL)
	break;
	}
}	}
	if (errorfile != NULL && sp == NULL) {
	fatalx(_("internal error, unable to find %s in list!"),
	sudoers);
	}
	break;
}	}
if (sp == NULL) {
errorx(1, _("internal error, unable to find %s in list!"),
sudoers);
}
}	}

/* If any new #include directives were added, edit them too. */	/* If any new #include directives were added, edit them too. */
Line 520 reparse_sudoers(char editor, char args, int strict,	Line 546 reparse_sudoers(char editor, char args, int strict,
continue;	continue;
edit_sudoers(sp, editor, args, errorlineno);	edit_sudoers(sp, editor, args, errorlineno);
}	}
} while (parse_error);

return TRUE;	/* If all sudoers files parsed OK we are done. */
	if (!parse_error)
	break;
	}

	debug_return_bool(true);
}	}

/*	/*
* Set the owner and mode on a sudoers temp file and	* Set the owner and mode on a sudoers temp file and
* move it into place. Returns TRUE on success, else FALSE.	* move it into place. Returns true on success, else false.
*/	*/
static int	static bool
install_sudoers(struct sudoersfile *sp, int oldperms)	install_sudoers(struct sudoersfile *sp, bool oldperms)
{	{
struct stat sb;	struct stat sb;
	bool rval = false;
	debug_decl(install_sudoers, SUDO_DEBUG_UTIL)

	if (!sp->modified) {
	/*
	* No changes but fix owner/mode if needed.
	*/
	(void) unlink(sp->tpath);
	if (!oldperms && fstat(sp->fd, &sb) != -1) {
	if (sb.st_uid != SUDOERS_UID \|\| sb.st_gid != SUDOERS_GID)
	ignore_result(chown(sp->path, SUDOERS_UID, SUDOERS_GID));
	if ((sb.st_mode & 0777) != SUDOERS_MODE)
	ignore_result(chmod(sp->path, SUDOERS_MODE));
	}
	rval = true;
	goto done;
	}

/*	/*
* Change mode and ownership of temp file so when	* Change mode and ownership of temp file so when
* we move it to sp->path things are kosher.	* we move it to sp->path things are kosher.
Line 541 install_sudoers(struct sudoersfile *sp, int oldperms)	Line 588 install_sudoers(struct sudoersfile *sp, int oldperms)
if (oldperms) {	if (oldperms) {
/* Use perms of the existing file. */	/* Use perms of the existing file. */
if (fstat(sp->fd, &sb) == -1)	if (fstat(sp->fd, &sb) == -1)
error(1, _("unable to stat %s"), sp->path);	fatal(_("unable to stat %s"), sp->path);
if (chown(sp->tpath, sb.st_uid, sb.st_gid) != 0) {	if (chown(sp->tpath, sb.st_uid, sb.st_gid) != 0) {
warning(_("unable to set (uid, gid) of %s to (%u, %u)"),	warning(_("unable to set (uid, gid) of %s to (%u, %u)"),
sp->tpath, (unsigned int)sb.st_uid, (unsigned int)sb.st_gid);	sp->tpath, (unsigned int)sb.st_uid, (unsigned int)sb.st_gid);
Line 554 install_sudoers(struct sudoersfile *sp, int oldperms)	Line 601 install_sudoers(struct sudoersfile *sp, int oldperms)
if (chown(sp->tpath, SUDOERS_UID, SUDOERS_GID) != 0) {	if (chown(sp->tpath, SUDOERS_UID, SUDOERS_GID) != 0) {
warning(_("unable to set (uid, gid) of %s to (%u, %u)"),	warning(_("unable to set (uid, gid) of %s to (%u, %u)"),
sp->tpath, SUDOERS_UID, SUDOERS_GID);	sp->tpath, SUDOERS_UID, SUDOERS_GID);
return FALSE;	goto done;
}	}
if (chmod(sp->tpath, SUDOERS_MODE) != 0) {	if (chmod(sp->tpath, SUDOERS_MODE) != 0) {
warning(_("unable to change mode of %s to 0%o"), sp->tpath,	warning(_("unable to change mode of %s to 0%o"), sp->tpath,
SUDOERS_MODE);	SUDOERS_MODE);
return FALSE;	goto done;
}	}
}	}

Line 593 install_sudoers(struct sudoersfile *sp, int oldperms)	Line 640 install_sudoers(struct sudoersfile *sp, int oldperms)
(void) unlink(sp->tpath);	(void) unlink(sp->tpath);
efree(sp->tpath);	efree(sp->tpath);
sp->tpath = NULL;	sp->tpath = NULL;
return FALSE;	goto done;
}	}
efree(sp->tpath);	efree(sp->tpath);
sp->tpath = NULL;	sp->tpath = NULL;
} else {	} else {
warning(_("error renaming %s, %s unchanged"), sp->tpath, sp->path);	warning(_("error renaming %s, %s unchanged"), sp->tpath, sp->path);
(void) unlink(sp->tpath);	(void) unlink(sp->tpath);
return FALSE;	goto done;
}	}
}	}
return TRUE;	rval = true;
	done:
	debug_return_bool(rval);
}	}

/* STUB */	/* STUB */
void	void
set_fqdn(void)
{
return;
}

/* STUB */
void
init_envtables(void)	init_envtables(void)
{	{
return;	return;
}	}

/* STUB */	/* STUB */
int	bool
user_is_exempt(void)	user_is_exempt(void)
{	{
return FALSE;	return false;
}	}

/* STUB */	/* STUB */
Line 645 sudo_endspent(void)	Line 687 sudo_endspent(void)
int	int
group_plugin_query(const char user, const char group, const struct passwd *pw)	group_plugin_query(const char user, const char group, const struct passwd *pw)
{	{
return FALSE;	return false;
}	}

	/* STUB */
	struct interface *get_interfaces(void)
	{
	return NULL;
	}

/*	/*
* Assuming a parse error occurred, prompt the user for what they want	* Assuming a parse error occurred, prompt the user for what they want
* to do now. Returns the first letter of their choice.	* to do now. Returns the first letter of their choice.
*/	*/
static char	static int
whatnow(void)	whatnow(void)
{	{
int choice, c;	int choice, c;
	debug_decl(whatnow, SUDO_DEBUG_UTIL)

for (;;) {	for (;;) {
(void) fputs(_("What now? "), stdout);	(void) fputs(_("What now? "), stdout);
Line 670 whatnow(void)	Line 719 whatnow(void)
case 'e':	case 'e':
case 'x':	case 'x':
case 'Q':	case 'Q':
return choice;	debug_return_int(choice);
default:	default:
(void) puts(_("Options are:\n"	(void) puts(_("Options are:\n"
" (e)dit sudoers file again\n"	" (e)dit sudoers file again\n"
Line 686 whatnow(void)	Line 735 whatnow(void)
static void	static void
setup_signals(void)	setup_signals(void)
{	{
sigaction_t sa;	sigaction_t sa;
	debug_decl(setup_signals, SUDO_DEBUG_UTIL)

/*	/*
* Setup signal handlers to cleanup nicely.	* Setup signal handlers to cleanup nicely.
*/	*/
zero_bytes(&sa, sizeof(sa));	memset(&sa, 0, sizeof(sa));
sigemptyset(&sa.sa_mask);	sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;	sa.sa_flags = SA_RESTART;
sa.sa_handler = quit;	sa.sa_handler = quit;
(void) sigaction(SIGTERM, &sa, NULL);	(void) sigaction(SIGTERM, &sa, NULL);
(void) sigaction(SIGHUP, &sa, NULL);	(void) sigaction(SIGHUP, &sa, NULL);
(void) sigaction(SIGINT, &sa, NULL);	(void) sigaction(SIGINT, &sa, NULL);
(void) sigaction(SIGQUIT, &sa, NULL);	(void) sigaction(SIGQUIT, &sa, NULL);

	debug_return;
}	}

static int	static int
Line 706 run_command(char path, char *argv)	Line 758 run_command(char path, char *argv)
{	{
int status;	int status;
pid_t pid, rv;	pid_t pid, rv;
	debug_decl(run_command, SUDO_DEBUG_UTIL)

switch (pid = fork()) {	switch (pid = sudo_debug_fork()) {
case -1:	case -1:
error(1, _("unable to execute %s"), path);	fatal(_("unable to execute %s"), path);
break; /* NOTREACHED */	break; /* NOTREACHED */
case 0:	case 0:
sudo_endpwent();	sudo_endpwent();
Line 725 run_command(char path, char *argv)	Line 778 run_command(char path, char *argv)
rv = waitpid(pid, &status, 0);	rv = waitpid(pid, &status, 0);
} while (rv == -1 && errno == EINTR);	} while (rv == -1 && errno == EINTR);

if (rv == -1 \|\| !WIFEXITED(status))	if (rv != -1)
return -1;	rv = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
return WEXITSTATUS(status);	debug_return_int(rv);
}	}

static int	static bool
check_syntax(char *sudoers_path, int quiet, int strict)	check_owner(const char *path, bool quiet)
{	{
struct stat sb;	struct stat sb;
int error;	bool ok = true;
	debug_decl(check_owner, SUDO_DEBUG_UTIL)

	if (stat(path, &sb) == 0) {
	if (sb.st_uid != SUDOERS_UID \|\| sb.st_gid != SUDOERS_GID) {
	ok = false;
	if (!quiet) {
	fprintf(stderr,
	_("%s: wrong owner (uid, gid) should be (%u, %u)\n"),
	path, SUDOERS_UID, SUDOERS_GID);
	}
	}
	if ((sb.st_mode & 07777) != SUDOERS_MODE) {
	ok = false;
	if (!quiet) {
	fprintf(stderr, _("%s: bad permissions, should be mode 0%o\n"),
	path, SUDOERS_MODE);
	}
	}
	}
	debug_return_bool(ok);
	}

	static bool
	check_syntax(char *sudoers_path, bool quiet, bool strict, bool oldperms)
	{
	bool ok = false;
	debug_decl(check_syntax, SUDO_DEBUG_UTIL)

if (strcmp(sudoers_path, "-") == 0) {	if (strcmp(sudoers_path, "-") == 0) {
yyin = stdin;	sudoersin = stdin;
sudoers_path = "stdin";	sudoers_path = "stdin";
} else if ((yyin = fopen(sudoers_path, "r")) == NULL) {	} else if ((sudoersin = fopen(sudoers_path, "r")) == NULL) {
if (!quiet)	if (!quiet)
warning(_("unable to open %s"), sudoers_path);	warning(_("unable to open %s"), sudoers_path);
exit(1);	goto done;
}	}
init_parser(sudoers_path, quiet);	init_parser(sudoers_path, quiet);
if (yyparse() && !parse_error) {	if (sudoersparse() && !parse_error) {
if (!quiet)	if (!quiet)
warningx(_("failed to parse %s file, unknown error"), sudoers_path);	warningx(_("failed to parse %s file, unknown error"), sudoers_path);
parse_error = TRUE;	parse_error = true;
errorfile = sudoers_path;	errorfile = sudoers_path;
}	}
if (!parse_error && check_aliases(strict, quiet) != 0) {	if (!parse_error) {
parse_error = TRUE;	if (!check_defaults(SETDEF_ALL, quiet) \|\|
errorfile = sudoers_path;	check_aliases(strict, quiet) != 0) {
	parse_error = true;
	errorfile = NULL;
	}
}	}
error = parse_error;	ok = !parse_error;
if (!quiet) {
if (parse_error) {	if (parse_error) {
	if (!quiet) {
if (errorlineno != -1)	if (errorlineno != -1)
(void) printf(_("parse error in %s near line %d\n"),	(void) printf(_("parse error in %s near line %d\n"),
errorfile, errorlineno);	errorfile, errorlineno);
else	else if (errorfile != NULL)
(void) printf(_("parse error in %s\n"), errorfile);	(void) printf(_("parse error in %s\n"), errorfile);
	}
	} else {
	struct sudoersfile *sp;

	/* Parsed OK, check mode and owner. */
	if (oldperms \|\| check_owner(sudoers_path, quiet)) {
	if (!quiet)
	(void) printf(_("%s: parsed OK\n"), sudoers_path);
} else {	} else {
(void) printf(_("%s: parsed OK\n"), sudoers_path);	ok = false;
}	}
}	tq_foreach_fwd(&sudoerslist, sp) {
/* Check mode and owner in strict mode. */	if (oldperms \|\| check_owner(sp->path, quiet)) {
if (strict && yyin != stdin && fstat(fileno(yyin), &sb) == 0) {	if (!quiet)
if (sb.st_uid != SUDOERS_UID \|\| sb.st_gid != SUDOERS_GID) {	(void) printf(_("%s: parsed OK\n"), sp->path);
error = TRUE;	} else {
if (!quiet) {	ok = false;
fprintf(stderr,
_("%s: wrong owner (uid, gid) should be (%u, %u)\n"),
sudoers_path, SUDOERS_UID, SUDOERS_GID);
}
}
if ((sb.st_mode & 07777) != SUDOERS_MODE) {
error = TRUE;
if (!quiet) {
fprintf(stderr, _("%s: bad permissions, should be mode 0%o\n"),
sudoers_path, SUDOERS_MODE);
}	}
}	}
}	}

return error;	done:
	debug_return_bool(ok);
}	}

/*	/*
Line 794 check_syntax(char *sudoers_path, int quiet, int strict	Line 877 check_syntax(char *sudoers_path, int quiet, int strict
* any subsequent files #included via a callback from the parser.	* any subsequent files #included via a callback from the parser.
*/	*/
FILE *	FILE *
open_sudoers(const char path, int doedit, int keepopen)	open_sudoers(const char path, bool doedit, bool keepopen)
{	{
struct sudoersfile *entry;	struct sudoersfile *entry;
FILE *fp;	FILE *fp;
	int open_flags;
	debug_decl(open_sudoers, SUDO_DEBUG_UTIL)

	if (checkonly)
	open_flags = O_RDONLY;
	else
	open_flags = O_RDWR \| O_CREAT;

/* Check for existing entry */	/* Check for existing entry */
tq_foreach_fwd(&sudoerslist, entry) {	tq_foreach_fwd(&sudoerslist, entry) {
if (strcmp(path, entry->path) == 0)	if (strcmp(path, entry->path) == 0)
break;	break;
}	}
if (entry == NULL) {	if (entry == NULL) {
entry = emalloc(sizeof(*entry));	entry = ecalloc(1, sizeof(*entry));
entry->path = estrdup(path);	entry->path = estrdup(path);
entry->modified = 0;	/* entry->modified = 0; */
entry->prev = entry;	entry->prev = entry;
entry->next = NULL;	/* entry->next = NULL; */
entry->fd = open(entry->path, O_RDWR \| O_CREAT, SUDOERS_MODE);	entry->fd = open(entry->path, open_flags, SUDOERS_MODE);
entry->tpath = NULL;	/* entry->tpath = NULL; */
entry->doedit = doedit;	entry->doedit = doedit;
if (entry->fd == -1) {	if (entry->fd == -1) {
warning("%s", entry->path);	warning("%s", entry->path);
efree(entry);	efree(entry);
return NULL;	debug_return_ptr(NULL);
}	}
if (!lock_file(entry->fd, SUDO_TLOCK))	if (!checkonly && !lock_file(entry->fd, SUDO_TLOCK))
errorx(1, _("%s busy, try again later"), entry->path);	fatalx(_("%s busy, try again later"), entry->path);
if ((fp = fdopen(entry->fd, "r")) == NULL)	if ((fp = fdopen(entry->fd, "r")) == NULL)
error(1, "%s", entry->path);	fatal("%s", entry->path);
tq_append(&sudoerslist, entry);	tq_append(&sudoerslist, entry);
} else {	} else {
/* Already exists, open .tmp version if there is one. */	/* Already exists, open .tmp version if there is one. */
if (entry->tpath != NULL) {	if (entry->tpath != NULL) {
if ((fp = fopen(entry->tpath, "r")) == NULL)	if ((fp = fopen(entry->tpath, "r")) == NULL)
error(1, "%s", entry->tpath);	fatal("%s", entry->tpath);
} else {	} else {
if ((fp = fdopen(entry->fd, "r")) == NULL)	if ((fp = fdopen(entry->fd, "r")) == NULL)
error(1, "%s", entry->path);	fatal("%s", entry->path);
rewind(fp);	rewind(fp);
}	}
}	}
if (keepopen != NULL)	if (keepopen != NULL)
*keepopen = TRUE;	*keepopen = true;
return fp;	debug_return_ptr(fp);
}	}

static char *	static char *
get_editor(char **args)	get_editor(char **args)
{	{
char Editor, EditorArgs, EditorPath, UserEditor, *UserEditorArgs;	char Editor, EditorArgs, EditorPath, UserEditor, *UserEditorArgs;
	debug_decl(get_editor, SUDO_DEBUG_UTIL)

/*	/*
* Check VISUAL and EDITOR environment variables to see which editor	* Check VISUAL and EDITOR environment variables to see which editor
Line 862 get_editor(char **args)	Line 953 get_editor(char **args)
} else {	} else {
if (def_env_editor) {	if (def_env_editor) {
/* If we are honoring $EDITOR this is a fatal error. */	/* If we are honoring $EDITOR this is a fatal error. */
errorx(1, _("specified editor (%s) doesn't exist"), UserEditor);	fatalx(_("specified editor (%s) doesn't exist"), UserEditor);
} else {	} else {
/* Otherwise, just ignore $EDITOR. */	/* Otherwise, just ignore $EDITOR. */
UserEditor = NULL;	UserEditor = NULL;
Line 885 get_editor(char **args)	Line 976 get_editor(char **args)

if (stat(UserEditor, &user_editor_sb) != 0) {	if (stat(UserEditor, &user_editor_sb) != 0) {
/* Should never happen since we already checked above. */	/* Should never happen since we already checked above. */
error(1, _("unable to stat editor (%s)"), UserEditor);	fatal(_("unable to stat editor (%s)"), UserEditor);
}	}
EditorPath = estrdup(def_editor);	EditorPath = estrdup(def_editor);
Editor = strtok(EditorPath, ":");	Editor = strtok(EditorPath, ":");
Line 933 get_editor(char **args)	Line 1024 get_editor(char **args)

/* Bleah, none of the editors existed! */	/* Bleah, none of the editors existed! */
if (Editor == NULL \|\| *Editor == '\0')	if (Editor == NULL \|\| *Editor == '\0')
errorx(1, _("no editor found (editor path = %s)"), def_editor);	fatalx(_("no editor found (editor path = %s)"), def_editor);
}	}
*args = EditorArgs;	*args = EditorArgs;
return Editor;	debug_return_str(Editor);
}	}

/*	/*
Line 946 static char *	Line 1037 static char *
get_args(char *cmnd)	get_args(char *cmnd)
{	{
char *args;	char *args;
	debug_decl(get_args, SUDO_DEBUG_UTIL)

args = cmnd;	args = cmnd;
while (args && !isblank((unsigned char) args))	while (args && !isblank((unsigned char) args))
Line 955 get_args(char *cmnd)	Line 1047 get_args(char *cmnd)
while (args && isblank((unsigned char) args))	while (args && isblank((unsigned char) args))
args++;	args++;
}	}
return *args ? args : NULL;	debug_return_str(*args ? args : NULL);
}	}

/*	/*
Line 964 get_args(char *cmnd)	Line 1056 get_args(char *cmnd)
static void	static void
get_hostname(void)	get_hostname(void)
{	{
char *p, thost[MAXHOSTNAMELEN + 1];	char *p, thost[HOST_NAME_MAX + 1];
	debug_decl(get_hostname, SUDO_DEBUG_UTIL)

if (gethostname(thost, sizeof(thost)) != 0) {	if (gethostname(thost, sizeof(thost)) != -1) {
user_host = user_shost = "localhost";	thost[sizeof(thost) - 1] = '\0';
return;	user_host = estrdup(thost);
}
thost[sizeof(thost) - 1] = '\0';
user_host = estrdup(thost);

if ((p = strchr(user_host, '.'))) {	if ((p = strchr(user_host, '.'))) {
*p = '\0';	*p = '\0';
user_shost = estrdup(user_host);	user_shost = estrdup(user_host);
*p = '.';	*p = '.';
	} else {
	user_shost = user_host;
	}
} else {	} else {
user_shost = user_host;	user_host = user_shost = "localhost";
}	}
	user_runhost = user_host;
	user_srunhost = user_shost;
	debug_return;
}	}

static int	static bool
alias_remove_recursive(char *name, int type, int strict, int quiet)	alias_remove_recursive(char *name, int type)
{	{
struct member *m;	struct member *m;
struct alias *a;	struct alias *a;
int error = 0;	bool rval = true;
	debug_decl(alias_remove_recursive, SUDO_DEBUG_ALIAS)

if ((a = alias_find(name, type)) != NULL) {	if ((a = alias_remove(name, type)) != NULL) {
tq_foreach_fwd(&a->members, m) {	tq_foreach_fwd(&a->members, m) {
if (m->type == ALIAS) {	if (m->type == ALIAS) {
if (!alias_remove_recursive(m->name, type, strict, quiet))	if (!alias_remove_recursive(m->name, type))
error = 1;	rval = false;
}	}
}	}
}
alias_seqno++;
a = alias_remove(name, type);
if (a)
rbinsert(alias_freelist, a);	rbinsert(alias_freelist, a);
return error;	}
	debug_return_bool(rval);
}	}

static int	static int
Line 1009 check_alias(char *name, int type, int strict, int quie	Line 1103 check_alias(char *name, int type, int strict, int quie
{	{
struct member *m;	struct member *m;
struct alias *a;	struct alias *a;
int error = 0;	int errors = 0;
	debug_decl(check_alias, SUDO_DEBUG_ALIAS)

if ((a = alias_find(name, type)) != NULL) {	if ((a = alias_get(name, type)) != NULL) {
/* check alias contents */	/* check alias contents */
tq_foreach_fwd(&a->members, m) {	tq_foreach_fwd(&a->members, m) {
if (m->type == ALIAS)	if (m->type == ALIAS)
error += check_alias(m->name, type, strict, quiet);	errors += check_alias(m->name, type, strict, quiet);
}	}
	alias_put(a);
} else {	} else {
if (!quiet) {	if (!quiet) {
char *fmt;
if (errno == ELOOP) {	if (errno == ELOOP) {
fmt = strict ?	warningx(strict ?
_("Error: cycle in %s_Alias `%s'") :	_("Error: cycle in %s_Alias `%s'") :
_("Warning: cycle in %s_Alias `%s'");	_("Warning: cycle in %s_Alias `%s'"),
	type == HOSTALIAS ? "Host" : type == CMNDALIAS ? "Cmnd" :
	type == USERALIAS ? "User" : type == RUNASALIAS ? "Runas" :
	"Unknown", name);
} else {	} else {
fmt = strict ?	warningx(strict ?
_("Error: %s_Alias `%s' referenced but not defined") :	_("Error: %s_Alias `%s' referenced but not defined") :
_("Warning: %s_Alias `%s' referenced but not defined");	_("Warning: %s_Alias `%s' referenced but not defined"),
	type == HOSTALIAS ? "Host" : type == CMNDALIAS ? "Cmnd" :
	type == USERALIAS ? "User" : type == RUNASALIAS ? "Runas" :
	"Unknown", name);
}	}
warningx(fmt,
type == HOSTALIAS ? "Host" : type == CMNDALIAS ? "Cmnd" :
type == USERALIAS ? "User" : type == RUNASALIAS ? "Runas" :
"Unknown", name);
}	}
error++;	errors++;
}	}

return error;	debug_return_int(errors);
}	}

/*	/*
Line 1045 check_alias(char *name, int type, int strict, int quie	Line 1142 check_alias(char *name, int type, int strict, int quie
* aliases or unused aliases.	* aliases or unused aliases.
*/	*/
static int	static int
check_aliases(int strict, int quiet)	check_aliases(bool strict, bool quiet)
{	{
struct cmndspec *cs;	struct cmndspec *cs;
struct member m, binding;	struct member m, binding;
struct privilege *priv;	struct privilege *priv;
struct userspec *us;	struct userspec *us;
struct defaults *d;	struct defaults *d;
int atype, error = 0;	int atype, errors = 0;
	debug_decl(check_aliases, SUDO_DEBUG_ALIAS)

alias_freelist = rbcreate(alias_compare);	alias_freelist = rbcreate(alias_compare);

Line 1060 check_aliases(int strict, int quiet)	Line 1158 check_aliases(int strict, int quiet)
tq_foreach_fwd(&userspecs, us) {	tq_foreach_fwd(&userspecs, us) {
tq_foreach_fwd(&us->users, m) {	tq_foreach_fwd(&us->users, m) {
if (m->type == ALIAS) {	if (m->type == ALIAS) {
alias_seqno++;	errors += check_alias(m->name, USERALIAS, strict, quiet);
error += check_alias(m->name, USERALIAS, strict, quiet);
}	}
}	}
tq_foreach_fwd(&us->privileges, priv) {	tq_foreach_fwd(&us->privileges, priv) {
tq_foreach_fwd(&priv->hostlist, m) {	tq_foreach_fwd(&priv->hostlist, m) {
if (m->type == ALIAS) {	if (m->type == ALIAS) {
alias_seqno++;	errors += check_alias(m->name, HOSTALIAS, strict, quiet);
error += check_alias(m->name, HOSTALIAS, strict, quiet);
}	}
}	}
tq_foreach_fwd(&priv->cmndlist, cs) {	tq_foreach_fwd(&priv->cmndlist, cs) {
tq_foreach_fwd(&cs->runasuserlist, m) {	tq_foreach_fwd(&cs->runasuserlist, m) {
if (m->type == ALIAS) {	if (m->type == ALIAS) {
alias_seqno++;	errors += check_alias(m->name, RUNASALIAS, strict, quiet);
error += check_alias(m->name, RUNASALIAS, strict, quiet);
}	}
}	}
if ((m = cs->cmnd)->type == ALIAS) {	if ((m = cs->cmnd)->type == ALIAS) {
alias_seqno++;	errors += check_alias(m->name, CMNDALIAS, strict, quiet);
error += check_alias(m->name, CMNDALIAS, strict, quiet);
}	}
}	}
}	}
Line 1090 check_aliases(int strict, int quiet)	Line 1184 check_aliases(int strict, int quiet)
tq_foreach_fwd(&userspecs, us) {	tq_foreach_fwd(&userspecs, us) {
tq_foreach_fwd(&us->users, m) {	tq_foreach_fwd(&us->users, m) {
if (m->type == ALIAS) {	if (m->type == ALIAS) {
alias_seqno++;	if (!alias_remove_recursive(m->name, USERALIAS))
if (!alias_remove_recursive(m->name, USERALIAS, strict, quiet))	errors++;
error++;
}	}
}	}
tq_foreach_fwd(&us->privileges, priv) {	tq_foreach_fwd(&us->privileges, priv) {
tq_foreach_fwd(&priv->hostlist, m) {	tq_foreach_fwd(&priv->hostlist, m) {
if (m->type == ALIAS) {	if (m->type == ALIAS) {
alias_seqno++;	if (!alias_remove_recursive(m->name, HOSTALIAS))
if (!alias_remove_recursive(m->name, HOSTALIAS, strict,	errors++;
quiet))
error++;
}	}
}	}
tq_foreach_fwd(&priv->cmndlist, cs) {	tq_foreach_fwd(&priv->cmndlist, cs) {
tq_foreach_fwd(&cs->runasuserlist, m) {	tq_foreach_fwd(&cs->runasuserlist, m) {
if (m->type == ALIAS) {	if (m->type == ALIAS) {
alias_seqno++;	if (!alias_remove_recursive(m->name, RUNASALIAS))
if (!alias_remove_recursive(m->name, RUNASALIAS,	errors++;
strict, quiet))
error++;
}	}
}	}
if ((m = cs->cmnd)->type == ALIAS) {	if ((m = cs->cmnd)->type == ALIAS) {
alias_seqno++;	if (!alias_remove_recursive(m->name, CMNDALIAS))
if (!alias_remove_recursive(m->name, CMNDALIAS, strict,	errors++;
quiet))
error++;
}	}
}	}
}	}
Line 1142 check_aliases(int strict, int quiet)	Line 1229 check_aliases(int strict, int quiet)
tq_foreach_fwd(&d->binding, binding) {	tq_foreach_fwd(&d->binding, binding) {
for (m = binding; m != NULL; m = m->next) {	for (m = binding; m != NULL; m = m->next) {
if (m->type == ALIAS) {	if (m->type == ALIAS) {
alias_seqno++;	if (!alias_remove_recursive(m->name, atype))
if (!alias_remove_recursive(m->name, atype, strict, quiet))	errors++;
error++;
}	}
}	}
}	}
Line 1155 check_aliases(int strict, int quiet)	Line 1241 check_aliases(int strict, int quiet)
if (!no_aliases() && !quiet)	if (!no_aliases() && !quiet)
alias_apply(print_unused, strict ? "Error" : "Warning");	alias_apply(print_unused, strict ? "Error" : "Warning");

return strict ? error : 0;	debug_return_int(strict ? errors : 0);
}	}

static int	static int
Line 1164 print_unused(void v1, void v2)	Line 1250 print_unused(void v1, void v2)
struct alias a = (struct alias )v1;	struct alias a = (struct alias )v1;
char prefix = (char )v2;	char prefix = (char )v2;

warningx(_("%s: unused %s_Alias %s"), prefix,	warningx_nodebug(_("%s: unused %s_Alias %s"), prefix,
a->type == HOSTALIAS ? "Host" : a->type == CMNDALIAS ? "Cmnd" :	a->type == HOSTALIAS ? "Host" : a->type == CMNDALIAS ? "Cmnd" :
a->type == USERALIAS ? "User" : a->type == RUNASALIAS ? "Runas" :	a->type == USERALIAS ? "User" : a->type == RUNASALIAS ? "Runas" :
"Unknown", a->name);	"Unknown", a->name);
Line 1174 print_unused(void v1, void v2)	Line 1260 print_unused(void v1, void v2)
/*	/*
* Unlink any sudoers temp files that remain.	* Unlink any sudoers temp files that remain.
*/	*/
void	static void
cleanup(int gotsignal)	visudo_cleanup(void)
{	{
struct sudoersfile *sp;	struct sudoersfile *sp;

Line 1183 cleanup(int gotsignal)	Line 1269 cleanup(int gotsignal)
if (sp->tpath != NULL)	if (sp->tpath != NULL)
(void) unlink(sp->tpath);	(void) unlink(sp->tpath);
}	}
if (!gotsignal) {	sudo_endpwent();
sudo_endpwent();	sudo_endgrent();
sudo_endgrent();
}
}	}

/*	/*
Line 1195 cleanup(int gotsignal)	Line 1279 cleanup(int gotsignal)
static void	static void
quit(int signo)	quit(int signo)
{	{
const char signame, myname;	struct sudoersfile *sp;
	struct iovec iov[4];

cleanup(signo);	tq_foreach_fwd(&sudoerslist, sp) {
	if (sp->tpath != NULL)
	(void) unlink(sp->tpath);
	}

#define emsg " exiting due to signal: "	#define emsg " exiting due to signal: "
myname = getprogname();	iov[0].iov_base = (char *)getprogname();
signame = strsignal(signo);	iov[0].iov_len = strlen(iov[0].iov_base);
if (write(STDERR_FILENO, myname, strlen(myname)) == -1 \|\|	iov[1].iov_base = emsg;
write(STDERR_FILENO, emsg, sizeof(emsg) - 1) == -1 \|\|	iov[1].iov_len = sizeof(emsg) - 1;
write(STDERR_FILENO, signame, strlen(signame)) == -1 \|\|	iov[2].iov_base = strsignal(signo);
write(STDERR_FILENO, "\n", 1) == -1)	iov[2].iov_len = strlen(iov[2].iov_base);
/* shut up glibc */;	iov[3].iov_base = "\n";
	iov[3].iov_len = 1;
	ignore_result(writev(STDERR_FILENO, iov, 4));
_exit(signo);	_exit(signo);
}	}

Line 1224 help(void)	Line 1315 help(void)
(void) printf(_("%s - safely edit the sudoers file\n\n"), getprogname());	(void) printf(_("%s - safely edit the sudoers file\n\n"), getprogname());
usage(0);	usage(0);
(void) puts(_("\nOptions:\n"	(void) puts(_("\nOptions:\n"
" -c check-only mode\n"	" -c, --check check-only mode\n"
" -f sudoers specify sudoers file location\n"	" -f, --file=file specify sudoers file location\n"
" -h display help message and exit\n"	" -h, --help display help message and exit\n"
" -q less verbose (quiet) syntax error messages\n"	" -q, --quiet less verbose (quiet) syntax error messages\n"
" -s strict syntax checking\n"	" -s, --strict strict syntax checking\n"
" -V display version information and exit"));	" -V, --version display version information and exit"));
exit(0);	exit(0);
}

static int
visudo_printf(int msg_type, const char *fmt, ...)
{
va_list ap;
FILE *fp;

switch (msg_type) {
case SUDO_CONV_INFO_MSG:
fp = stdout;
break;
case SUDO_CONV_ERROR_MSG:
fp = stderr;
break;
default:
errno = EINVAL;
return -1;
}

va_start(ap, fmt);
vfprintf(fp, fmt, ap);
va_end(ap);

return 0;
}	}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1
changed lines
	Added in v.1.1.1.5