xref: /onnv-gate/usr/src/cmd/saf/pmadm.c (revision 334:249936f45018)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "extern.h"
#include "misc.h"
#include <sac.h>
#include "structs.h"

#define	ADD		0x1	/* -a or other required options seen */
#define	REMOVE		0x2	/* -r seen */
#define	ENABLE		0x4	/* -e seen */
#define	DISABLE		0x8	/* -d seen */
#define	PLIST		0x10	/* -l seen */
#define	LIST		0x20	/* -L seen */
#define	CONFIG		0x40	/* -g seen */

# define U_FLAG		0x1	/* -fu seen */
# define X_FLAG		0x2	/* -fx seen */

/*
 * functions
 */

char	*pflags();
char	*pspec();
struct	taglist	*find_type();
void	usage();
void	parseline();
void	add_svc();
void	rem_svc();
void	ed_svc();
void	list_svcs();
void	doconf();

/*
 * format of a _pmtab entry - used to hold parsed info
 */

struct	pmtab {
	char	*p_tag;		/* service tag */
	long	p_flags;	/* flags */
	char	*p_id;		/* logname to start service as */
	char	*p_res1;	/* reserved field */
	char	*p_res2;	/* reserved field */
	char	*p_res3;	/* reserved field */
	char	*p_pmspec;	/* port monitor specific info */
};

/*
 * format of a tag list, which is a list of port monitor tags of
 * a designated type
 */

struct	taglist {
	struct	taglist	*t_next;	/* next in list */
	char	t_tag[PMTAGSIZE + 1];	/* PM tag */
	char	t_type[PMTYPESIZE + 1];	/* PM type */
};

/*
 * common error messages
 */

# define NOTPRIV	"User not privileged for operation"
# define BADINP		"Embedded newlines not allowed"

int	Saferrno;	/* internal `errno' for exit */


/*
 * main - scan args for pmadm and call appropriate handling code
 */

int
main(int argc, char *argv[])
{
	int c;			/* option letter */
	int ret;		/* return code from check_version */
	uid_t uid;		/* invoker's real uid */
	int flag = 0;		/* flag to record requested operations */
	int errflg = 0;		/* error indicator */
	int badcnt = 0;		/* count of bad args to -f */
	int version = -1;	/* argument to -v */
	int sawaflag = 0;	/* true if actually saw -a */
	int conflag = 0;	/* true if output should be in condensed form */
	long flags = 0;		/* arguments to -f */
	char *pmtag = NULL;	/* argument to -p */
	char *type = NULL;	/* argument to -t */
	char *script = NULL;	/* argument to -z */
	char *comment = " ";	/* argument to -y */
	char *id = NULL;	/* argument to -i */
	char *svctag = NULL;	/* argument to -s */
	char *pmspec = NULL;	/* argument to -m */
	char badargs[SIZE];	/* place to hold bad args to -f */
	char buf[SIZE];		/* scratch buffer */
	register char *p;	/* scratch pointer */

	if (argc == 1)
		usage(argv[0]);
	while ((c = getopt(argc, argv, "adef:gi:Llm:p:rs:t:v:y:z:")) != -1) {
		switch (c) {
		case 'a':
			flag |= ADD;
			sawaflag = 1;
			break;
		case 'd':
			flag |= DISABLE;
			break;
		case 'e':
			flag |= ENABLE;
			break;
		case 'f':
			flag |= ADD;
			while (*optarg) {
				switch (*optarg++) {
				case 'u':
					flags |= U_FLAG;
					break;
				case 'x':
					flags |= X_FLAG;
					break;
				default:
					badargs[badcnt++] = *(optarg - 1);
					break;
				}
			}
			/* null terminate just in case anything is there */
			badargs[badcnt] = '\0';
			break;
		case 'g':
			flag |= CONFIG;
			break;
		case 'i':
			if (strchr(optarg, '\n')) {
				Saferrno = E_BADARGS;
				error(BADINP);
			}
			flag |= ADD;
			id = optarg;
			break;
		case 'L':
			flag |= LIST;
			break;
		case 'l':
			flag |= PLIST;
			break;
		case 'm':
			if (strchr(optarg, '\n')) {
				Saferrno = E_BADARGS;
				error(BADINP);
			}
			if (*optarg == '\0') {
				/* this will generate a usage message below */
				errflg++;
				break;
			}
			flag |= ADD;
			pmspec = optarg;
			break;
		case 'p':
			if (strchr(optarg, '\n')) {
				Saferrno = E_BADARGS;
				error(BADINP);
			}
			pmtag = optarg;
			if (strlen(pmtag) > PMTAGSIZE) {
				pmtag[PMTAGSIZE] = '\0';
				(void) fprintf(stderr, "tag too long, truncated to <%s>\n", pmtag);
			}
			for (p = pmtag; *p; p++) {
				if (!isalnum(*p)) {
					Saferrno = E_BADARGS;
					error("port monitor tag must be alphanumeric");
				}
			}
			break;
		case 'r':
			flag |= REMOVE;
			break;
		case 's':
			if (strchr(optarg, '\n')) {
				Saferrno = E_BADARGS;
				error(BADINP);
			}
			svctag = optarg;
			if (strlen(svctag) > SVCTAGSIZE) {
				svctag[SVCTAGSIZE] = '\0';
				(void) fprintf(stderr, "svctag too long, truncated to <%s>\n", svctag);
			}
			for (p = svctag; *p; p++) {
				if (!isalnum(*p)) {
					Saferrno = E_BADARGS;
					error("service tag must be alphanumeric");
				}
			}
			break;
		case 't':
			if (strchr(optarg, '\n')) {
				Saferrno = E_BADARGS;
				error(BADINP);
			}
			type = optarg;
			if (strlen(type) > PMTYPESIZE) {
				type[PMTYPESIZE] = '\0';
				(void) fprintf(stderr, "type too long, truncated to <%s>\n", type);
			}
			for (p = type; *p; p++) {
				if (!isalnum(*p)) {
					Saferrno = E_BADARGS;
					error("port monitor type must be alphanumeric");
				}
			}
			break;
		case 'v':
			flag |= ADD;
			version = atoi(optarg);
			if (version < 0) {
				Saferrno = E_BADARGS;
				error("version number can not be negative");
			}
			break;
		case 'y':
			if (strchr(optarg, '\n')) {
				Saferrno = E_BADARGS;
				error(BADINP);
			}
			flag |= ADD;
			comment = optarg;
			break;
		case 'z':
			if (strchr(optarg, '\n')) {
				Saferrno = E_BADARGS;
				error(BADINP);
			}
			script = optarg;
			break;
		case '?':
			errflg++;
		}
	}
	if (errflg || (optind < argc))
		usage(argv[0]);

	if (badcnt) {
		/* bad flags were given to -f */
		(void) sprintf(buf, "Invalid request, %s are not valid arguments for \"-f\"", badargs);
		Saferrno = E_BADARGS;
		error(buf);
	}

	uid = getuid();

/*
 * don't do anything if _sactab isn't the version we understand
 */

	if ((ret = check_version(VERSION, SACTAB)) == 1) {
		Saferrno = E_SAFERR;
		error("_sactab version number is incorrect");
	}
	else if (ret == 2) {
		(void) sprintf(buf, "could not open %s", SACTAB);
		Saferrno = E_SYSERR;
		error(buf);
	}
	else if (ret == 3) {
		(void) sprintf(buf, "%s file is corrupt", SACTAB);
		Saferrno = E_SAFERR;
		error(buf);
	}

	switch (flag) {
	case ADD:
		if (uid) {
			Saferrno = E_NOPRIV;
			error(NOTPRIV);
		}
		if (!sawaflag || (pmtag && type) || (!pmtag && !type) || !svctag || !id || !pmspec || (version < 0))
			usage(argv[0]);
		add_svc(pmtag, type, svctag, id, pmspec, flags, version, comment, script);
		break;
	case REMOVE:
		if (uid) {
			Saferrno = E_NOPRIV;
			error(NOTPRIV);
		}
		if (!pmtag || !svctag || type || script)
			usage(argv[0]);
		rem_svc(pmtag, svctag);
		break;
	case ENABLE:
		if (uid) {
			Saferrno = E_NOPRIV;
			error(NOTPRIV);
		}
		if (!pmtag || !svctag || type || script)
			usage(argv[0]);
		ed_svc(pmtag, svctag, ENABLE);
		break;
	case DISABLE:
		if (uid) {
			Saferrno = E_NOPRIV;
			error(NOTPRIV);
		}
		if (!pmtag || !svctag || type || script)
			usage(argv[0]);
		ed_svc(pmtag, svctag, DISABLE);
		break;
	case LIST:
		conflag = 1;
		/* fall through */
	case PLIST:
		if ((pmtag && type) || script)
			usage(argv[0]);
		list_svcs(pmtag, type, svctag, conflag);
		break;
	case CONFIG:
		if (script && uid) {
			Saferrno = E_NOPRIV;
			error(NOTPRIV);
		}
		if ((pmtag && type) || (!pmtag && !type) || !svctag || (type && !script))
			usage(argv[0]);
		doconf(script, pmtag, type, svctag);
		break;
	default:
		/* we only get here if more than one flag bit was set */
		usage(argv[0]);
		/* NOTREACHED */
	}
	quit();
	/* NOTREACHED */
}


/*
 * usage - print out a usage message
 *
 *	args:	cmdname - the name command was invoked with
 */

void
usage(cmdname)
char *cmdname;
{
	(void) fprintf(stderr, "Usage:\t%s -a [ -p pmtag | -t type ] -s svctag -i id -m \"pmspecific\"\n", cmdname);
	(void) fprintf(stderr, "\t\t-v version [ -f xu ] [ -y comment ] [ -z script]\n");
	(void) fprintf(stderr, "\t%s -r -p pmtag -s svctag\n", cmdname);
	(void) fprintf(stderr, "\t%s -e -p pmtag -s svctag\n", cmdname);
	(void) fprintf(stderr, "\t%s -d -p pmtag -s svctag\n", cmdname);
	(void) fprintf(stderr, "\t%s -l [ -p pmtag | -t type ] [ -s svctag ]\n", cmdname);
	(void) fprintf(stderr, "\t%s -L [ -p pmtag | -t type ] [ -s svctag ]\n", cmdname);
	(void) fprintf(stderr, "\t%s -g -p pmtag -s svctag [ -z script ]\n", cmdname);
	(void) fprintf(stderr, "\t%s -g -s svctag -t type -z script\n", cmdname);
	Saferrno = E_BADARGS;
	quit();
}


/*
 * add_svc - add a service entry
 *
 *	args:	tag - port monitor's tag (may be null)
 *		type - port monitor's type (may be null)
 *		svctag - service's tag
 *		id - identity under which service should run
 *		pmspec - uninterpreted port monitor-specific info
 *		flags - service flags
 *		version - version number of port monitor's pmtab
 *		comment - comment describing service
 *		script - service's configuration script
 */

void
add_svc(tag, type, svctag, id, pmspec, flags, version, comment, script)
char *tag;
char *type;
char *svctag;
char *id;
char *pmspec;
long flags;
int version;
char *comment;
char *script;
{
	FILE *fp;			/* scratch file pointer */
	struct taglist tl;		/* 'list' for degenerate case (1 PM) */
	register struct taglist *tp = NULL;	/* working pointer */
	int ret;			/* return code from check_version */
	char buf[SIZE];			/* scratch buffer */
	char fname[SIZE];		/* scratch buffer for building names */
	int added;			/* count number added */

	fp = fopen(SACTAB, "r");
	if (fp == NULL) {
		Saferrno = E_SYSERR;
		error("Could not open _sactab");
	}
	if (tag && !find_pm(fp, tag)) {
		(void) sprintf(buf, "Invalid request, %s does not exist", tag);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	if (type && !(tp = find_type(fp, type))) {
		(void) sprintf(buf, "Invalid request, %s does not exist", type);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	(void) fclose(fp);

	if (tag) {

/*
 * treat the case of 1 PM as a degenerate case of a list of PMs from a
 * type specification.  Build the 'list' here.
 */

		tp = &tl;
		tp->t_next = NULL;
		(void) strcpy(tp->t_tag, tag);
	}

	added = 0;
	while (tp) {
		(void) sprintf(fname, "%s/%s/_pmtab", HOME, tp->t_tag);
		if ((ret = check_version(version, fname)) == 1) {
			(void) sprintf(buf, "%s version number is incorrect", fname);
			Saferrno = E_SAFERR;
			error(buf);
		}
		else if (ret == 2) {
			(void) sprintf(buf, "could not open %s", fname);
			Saferrno = E_SYSERR;
			error(buf);
		}
		else if (ret == 3) {
			(void) sprintf(buf, "%s file is corrupt", fname);
			Saferrno = E_SAFERR;
			error(buf);
		}
		fp = fopen(fname, "r");
		if (fp == NULL) {
			(void) sprintf(buf, "Could not open %s", fname);
			Saferrno = E_SYSERR;
			error(buf);
		}
		if (find_svc(fp, tp->t_tag, svctag)) {
			if (tag) {
				/* special case of tag only */
				(void) sprintf(buf, "Invalid request, %s already exists under %s", svctag, tag);
				Saferrno = E_DUP;
				error(buf);
			}
			else {
				(void) fprintf(stderr, "warning - %s already exists under %s - ignoring\n", svctag, tp->t_tag);
				tp = tp->t_next;
				(void) fclose(fp);
				continue;
			}
		}
		(void) fclose(fp);

/*
 * put in the config script, if specified
*/

		if (script) {
			(void) sprintf(fname, "%s/%s", tp->t_tag, svctag);
			if (do_config(script, fname)) {
				/* do_config put out any messages */
				tp = tp->t_next;
				continue;
			}
		}

/*
 * add the line
 */

		(void) sprintf(fname, "%s/%s/_pmtab", HOME, tp->t_tag);
		fp = fopen(fname, "a");
		if (fp == NULL) {
			(void) sprintf(buf, "Could not open %s", fname);
			Saferrno = E_SYSERR;
			error(buf);
		}
		(void) fprintf(fp, "%s:%s:%s:reserved:reserved:reserved:%s#%s\n",
			svctag, (flags ? pflags(flags, FALSE) : ""), id, pmspec,
			(comment ? comment : ""));
		(void) fclose(fp);
		added++;

/*
 * tell the SAC to to tell PM to read _pmtab
 */

		(void) tell_sac(tp->t_tag);
		tp = tp->t_next;
	}
	if (added == 0) {
		Saferrno = E_SAFERR;
		error("No services added");
	}
	return;
}


/*
 * rem_svc - remove a service
 *
 *	args:	pmtag - tag of port monitor responsible for the service
 *		svctag - tag of the service to be removed
 */

void
rem_svc(pmtag, svctag)
char *pmtag;
char *svctag;
{
	FILE *fp;		/* scratch file pointer */
	FILE *tfp;		/* file pointer for temp file */
	int line;		/* line number entry is on */
	char *tname;		/* temp file name */
	char buf[SIZE];		/* scratch buffer */
	char fname[SIZE];	/* path to correct _pmtab */

	fp = fopen(SACTAB, "r");
	if (fp == NULL) {
		Saferrno = E_SYSERR;
		error("Could not open _sactab");
	}
	if (!find_pm(fp, pmtag)) {
		(void) sprintf(buf, "Invalid request, %s does not exist", pmtag);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	(void) fclose(fp);

	(void) sprintf(fname, "%s/_pmtab", pmtag);
	(void) sprintf(buf, "%s/%s", HOME, fname);
	fp = fopen(buf, "r");
	if (fp == NULL) {
		(void) sprintf(buf, "Could not open %s/%s", HOME, fname);
		Saferrno = E_SYSERR;
		error(buf);
	}
	if ((line = find_svc(fp, pmtag, svctag)) == 0) {
		(void) sprintf(buf, "Invalid request, %s does not exist under %s", svctag, pmtag);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	tname = make_tempname(fname);
	tfp = open_temp(tname);
	if (line != 1) {
		if (copy_file(fp, tfp, 1, line - 1)) {
			(void) unlink(tname);
			Saferrno = E_SYSERR;
			error("error accessing temp file");
		}
	}
	if (copy_file(fp, tfp, line + 1, -1)) {
		(void) unlink(tname);
		Saferrno = E_SYSERR;
		error("error accessing temp file");
	}
	(void) fclose(fp);
	if (fclose(tfp) == EOF) {
		(void) unlink(tname);
		Saferrno = E_SYSERR;
		error("error closing tempfile");
	}
	/* note - replace only returns if successful */
	replace(fname, tname);

/*
 * tell the SAC to to tell PM to read _pmtab
 */

	if (tell_sac(pmtag)) {

/*
 * if we got rid of the service, try to remove the config script too.
 * Don't check return status since it may not have existed anyhow.
 */

		(void) sprintf(buf, "%s/%s/%s", HOME, pmtag, svctag);
		(void) unlink(buf);
		return;
	}
}



/*
 * ed_svc - enable or disable a particular service
 *
 *	args:	pmtag - tag of port monitor responsible for the service
 *		svctag - tag of service to be enabled or disabled
 *		flag - operation to perform (ENABLE or DISABLE)
 */

void
ed_svc(pmtag, svctag, flag)
char *pmtag;
char *svctag;
int flag;
{
	FILE *fp;		/* scratch file pointer */
	FILE *tfp;		/* file pointer for temp file */
	int line;		/* line number entry is on */
	register char *from;	/* working pointer */
	register char *to;	/* working pointer */
	char *tname;		/* temp file name */
	char *p;		/* scratch pointer */
	char buf[SIZE];		/* scratch buffer */
	char tbuf[SIZE];	/* scratch buffer */
	char fname[SIZE];	/* path to correct _pmtab */

	fp = fopen(SACTAB, "r");
	if (fp == NULL) {
		Saferrno = E_SYSERR;
		error("Could not open _sactab");
	}
	if (!find_pm(fp, pmtag)) {
		(void) sprintf(buf, "Invalid request, %s does not exist", pmtag);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	(void) fclose(fp);

	(void) sprintf(fname, "%s/_pmtab", pmtag);
	(void) sprintf(buf, "%s/%s", HOME, fname);
	fp = fopen(buf, "r");
	if (fp == NULL) {
		(void) sprintf(buf, "Could not open %s/%s", HOME, fname);
		Saferrno = E_SYSERR;
		error(buf);
	}
	if ((line = find_svc(fp, pmtag, svctag)) == 0) {
		(void) sprintf(buf, "Invalid request, %s does not exist under %s", svctag, pmtag);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	tname = make_tempname(fname);
	tfp = open_temp(tname);
	if (line != 1) {
		if (copy_file(fp, tfp, 1, line - 1)) {
			(void) unlink(tname);
			Saferrno = E_SYSERR;
			error("error accessing temp file");
		}
	}

/*
 * Note: find_svc above has already read and parsed this entry, thus
 * we know it to be well-formed, so just change the flags as appropriate
 */

	if (fgets(buf, SIZE, fp) == NULL) {
		(void) unlink(tname);
		Saferrno = E_SYSERR;
		error("error accessing temp file");
	}
	from = buf;
	to = tbuf;

/*
 * copy initial portion of entry
 */

	p = strchr(from, DELIMC);
	for ( ; from <= p; )
		*to++ = *from++;

/*
 * isolate and fix the flags
 */

	p = strchr(from, DELIMC);
	for ( ; from < p; ) {
		if (*from == 'x') {
			from++;
			continue;
		}
		*to++ = *from++;
	}

/*
 * above we removed x flag, if this was a disable operation, stick it in
 * and also copy the field delimiter
 */

	if (flag == DISABLE)
		*to++ = 'x';
	*to++ = *from++;

/*
 * copy the rest of the line
 */

	for ( ; from < &buf[SIZE - 1] ;)
		*to++ = *from++;
/***	*to = '\0';  BUG: Don't uncomment it ****/

	(void) fprintf(tfp, "%s", tbuf);

	if (copy_file(fp, tfp, line + 1, -1)) {
		(void) unlink(tname);
		Saferrno = E_SYSERR;
		error("error accessing temp file");
	}
	(void) fclose(fp);
	if (fclose(tfp) == EOF) {
		(void) unlink(tname);
		Saferrno = E_SYSERR;
		error("error closing tempfile");
	}
	/* note - replace only returns if successful */
	replace(fname, tname);


/*
 * tell the SAC to to tell PM to read _pmtab
 */

	(void) tell_sac(pmtag);
}


/*
 * doconf - take a config script and have it put where it belongs or
 *	    output an existing one
 *
 *	args:	script - name of file containing script (if NULL, means
 *			 output existing one instead)
 *		tag - tag of port monitor that is responsible for the
 *		      designated service (may be null)
 *		type - type of port monitor that is responsible for the
 *		       designated service (may be null)
 *		svctag - tag of service whose config script we're operating on
 */

void
doconf(script, tag, type, svctag)
char *script;
char *tag;
char *type;
char *svctag;
{
	FILE *fp;			/* scratch file pointer */
	int added;			/* count of config scripts added */
	struct taglist tl;		/* 'list' for degenerate case (1 PM) */
	register struct taglist *tp = NULL;	/* working pointer */
	char buf[SIZE];			/* scratch buffer */
	char fname[SIZE];		/* scratch buffer for names */

	fp = fopen(SACTAB, "r");
	if (fp == NULL) {
		Saferrno = E_SYSERR;
		error("Could not open _sactab");
	}
	if (tag && !find_pm(fp, tag)) {
		(void) sprintf(buf, "Invalid request, %s does not exist", tag);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	if (type && !(tp = find_type(fp, type))) {
		(void) sprintf(buf, "Invalid request, %s does not exist", type);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	(void) fclose(fp);

	if (tag) {

/*
 * treat the case of 1 PM as a degenerate case of a list of PMs from a
 * type specification.  Build the 'list' here.
 */

		tp = &tl;
		tp->t_next = NULL;
		(void) strcpy(tp->t_tag, tag);
	}

	added = 0;
	while (tp) {
		(void) sprintf(fname, "%s/%s/_pmtab", HOME, tp->t_tag);
		fp = fopen(fname, "r");
		if (fp == NULL) {
			(void) sprintf(buf, "Could not open %s", fname);
			Saferrno = E_SYSERR;
			error(buf);
		}
		if (!find_svc(fp, tp->t_tag, svctag)) {
			if (tag) {
				/* special case of tag only */
				(void) sprintf(buf, "Invalid request, %s does not exist under %s", svctag, tag);
				Saferrno = E_NOEXIST;
				error(buf);
			}
			else {
				(void) fprintf(stderr, "warning - %s does not exist under %s - ignoring\n", svctag, tp->t_tag);
				Saferrno = E_NOEXIST;
				tp = tp->t_next;
				(void) fclose(fp);
				continue;
			}
		}
		(void) fclose(fp);

		(void) sprintf(fname, "%s/%s", tp->t_tag, svctag);

/*
 * do_config does all the real work (keep track if any errors occurred)
 */

		if (do_config(script, fname) == 0)
			added++;
		tp = tp->t_next;
	}
	if (added == 0) {
		Saferrno = E_SAFERR;
		error("No configuration scripts installed");
	}
	return;
}


/*
 * tell_sac - use sacadm to tell the sac to tell a port monitor to read
 *	its _pmtab.  Return TRUE on success, FALSE on failure.
 *
 *	args:	tag - tag of port monitor to be notified
 */


int
tell_sac(char *tag)
{
	pid_t pid;	/* returned pid from fork */
	int status;	/* return status from sacadm child */

	if ((pid = fork()) < 0) {
		(void) fprintf(stderr, "warning - fork failed - could not notify <%s> about modified table\n", tag);
		(void) fprintf(stderr, "try executing the command \"sacadm -x -p %s\"\n", tag);
		Saferrno = E_SYSERR;
		return(FALSE);
	}
	else if (pid) {
		/* parent */
		(void) wait(&status);
		if (status) {
			if (((status >> 8) & 0xff) == E_PMNOTRUN) {
				(void) fprintf(stderr, "warning - port monitor, %s is not running\n", tag);
				return (FALSE);
			}
			if (((status >> 8) & 0xff) == E_SACNOTRUN) {
				Saferrno = E_SACNOTRUN;
			} else {
				Saferrno = E_SYSERR;
			}
			(void) fprintf(stderr,
			    "warning - could not notify <%s> about modified"
			    " table\n", tag);
			(void) fprintf(stderr, "try executing the command"
			    " \"sacadm -x -p %s\"\n", tag);
			return(FALSE);
		}
		else {
			return(TRUE);
		}
	}
	else {
		/* set IFS for security */
		(void) putenv("IFS=\" \"");
		/* muffle sacadm warning messages */
		(void) fclose(stderr);
		(void) fopen("/dev/null", "w");
		(void) execl("/usr/sbin/sacadm", "sacadm", "-x", "-p", tag, 0);

/*
 * if we got here, it didn't work, exit status will clue in parent to
 * put out the warning
 */

		exit(1);
	}
	/* NOTREACHED */
}


/*
 * list_svcs - list information about services
 *
 *	args:	pmtag - tag of port monitor responsible for the service
 *			(may be null)
 *		type - type of port monitor responsible for the service
 *		       (may be null)
 *		svctag - tag of service to be listed (may be null)
 *		oflag - true if output should be easily parseable
 */

void
list_svcs(pmtag, type, svctag, oflag)
char *pmtag;
char *type;
char *svctag;
{
	FILE *fp;				/* scratch file pointer */
	register struct taglist *tp;		/* pointer to PM list */
	int nprint = 0;				/* count # of svcs printed */
	struct pmtab pmtab;			/* place to hold parsed info */
	register struct pmtab *pp = &pmtab;	/* and a pointer to it */
	register char *p;			/* working pointer */
	char buf[SIZE];				/* scratch buffer */
	char fname[SIZE];			/* scratch buffer for building names */

	fp = fopen(SACTAB, "r");
	if (fp == NULL) {
		Saferrno = E_SYSERR;
		error("Could not open _sactab");
	}
	if (pmtag && !find_pm(fp, pmtag)) {
		(void) sprintf(buf, "Invalid request, %s does not exist", pmtag);
		Saferrno = E_NOEXIST;
		error(buf);
	}
	rewind(fp);
	if (type) {
		tp = find_type(fp, type);
		if (tp == NULL) {
			(void) sprintf(buf, "Invalid request, %s does not exist", type);
			Saferrno = E_NOEXIST;
			error(buf);
		}
	}
	else
		tp = find_type(fp, NULL);
	(void) fclose(fp);

	while (tp) {
		if (pmtag && strcmp(tp->t_tag, pmtag)) {
			/* not interested in this port monitor */
			tp = tp->t_next;
			continue;
		}
		(void) sprintf(fname, "%s/%s/_pmtab", HOME, tp->t_tag);
		fp = fopen(fname, "r");
		if (fp == NULL) {
			(void) sprintf(buf, "Could not open %s", fname);
			Saferrno = E_SYSERR;
			error(buf);
		}
		while (fgets(buf, SIZE, fp)) {
			p = trim(buf);
			if (*p == '\0')
				continue;
			parseline(p, pp, tp->t_tag);
			if (!svctag || !strcmp(pp->p_tag, svctag)) {
				if (oflag) {
					(void) printf("%s:%s:%s:%s:%s:%s:%s:%s:%s#%s\n",
						tp->t_tag, tp->t_type, pp->p_tag,
						pflags(pp->p_flags, FALSE),
						pp->p_id, pp->p_res1, pp->p_res2,
						pp->p_res3,pp->p_pmspec, Comment);
				}
				else {
					if (nprint == 0) {
						(void) printf("PMTAG          PMTYPE         SVCTAG         FLGS ID       <PMSPECIFIC>\n");
					}
					(void) printf("%-14s %-14s %-14s %-4s %-8s %s #%s\n", tp->t_tag, tp->t_type, pp->p_tag,
						pflags(pp->p_flags, TRUE), pp->p_id, pspec(pp->p_pmspec), Comment);
				}
				nprint++;
			}
		}
		if (!feof(fp)) {
			(void) sprintf(buf, "error reading %s", fname);
			Saferrno = E_SYSERR;
			error(buf);
		}
		else {
			(void) fclose(fp);
			tp = tp->t_next;
		}
	}
	/* if we didn't find any valid ones, indicate an error */
	if (nprint == 0) {
		if (svctag)
			(void) fprintf(stderr, "Service <%s> does not exist\n", svctag);
		else
			(void) fprintf(stderr, "No services defined\n");
		Saferrno = E_NOEXIST;
	}
	return;
}


/*
 * find_svc - find an entry in _pmtab for a particular service tag
 *
 *	args:	fp - file pointer for _pmtab
 *		tag - port monitor tag (for error reporting)
 *		svctag - tag of service we're looking for
 */

int
find_svc(FILE *fp, char *tag, char *svctag)
{
	register char *p;	/* working pointer */
	int line = 0;		/* line number we found entry on */
	struct pmtab pmtab;	/* place to hold parsed info */
	static char buf[SIZE];	/* scratch buffer */

	while (fgets(buf, SIZE, fp)) {
		line++;
		p = trim(buf);
		if (*p == '\0')
			continue;
		parseline(p, &pmtab, tag);
		if (!(strcmp(pmtab.p_tag, svctag)))
			return(line);
	}
	if (!feof(fp)) {
		(void) sprintf(buf, "error reading %s/%s/_pmtab", HOME, tag);
		Saferrno = E_SYSERR;
		error(buf);
		/* NOTREACHED */
		return (0);
	} else
		return (0);
}


/*
 * parseline - parse a line from _pmtab.  This routine will return if the
 *		parse wa successful, otherwise it will output an error and
 *		exit.
 *
 *	args:	p - pointer to the data read from the file (note - this is
 *		    a static data region, so we can point into it)
 *		pp - pointer to a structure in which the separated fields
 *		     are placed
 *		tag - port monitor tag (for error reporting)
 *
 *	A line in the file has the following format:
 *
 *	tag:flags:identity:reserved:reserved:reserved:PM_spec_info # comment
 */


void
parseline(p, pp, tag)
register char *p;
register struct pmtab *pp;
char *tag;
{
	char buf[SIZE];	/* scratch buffer */

/*
 * get the service tag
 */

	p = nexttok(p, DELIM, FALSE);
	if (p == NULL) {
		(void) sprintf(buf, "%s/%s/_pmtab is corrupt", HOME, tag);
		Saferrno = E_SAFERR;
		error(buf);
	}
	if (strlen(p) > PMTAGSIZE) {
		p[PMTAGSIZE] = '\0';
		(void) fprintf(stderr, "tag too long, truncated to <%s>", p);
	}
	pp->p_tag = p;

/*
 * get the flags
 */

	p = nexttok(NULL, DELIM, FALSE);
	if (p == NULL) {
		(void) sprintf(buf, "%s/%s/_pmtab is corrupt", HOME, tag);
		Saferrno = E_SAFERR;
		error(buf);
	}
	pp->p_flags = 0;
	while (*p) {
		switch (*p++) {
		case 'u':
			pp->p_flags |= U_FLAG;
			break;
		case 'x':
			pp->p_flags |= X_FLAG;
			break;
		default:
			(void) sprintf(buf, "Unrecognized flag <%c>", *(p - 1));
			Saferrno = E_SAFERR;
			error(buf);
			break;
		}
	}

/*
 * get the identity
 */

	p = nexttok(NULL, DELIM, FALSE);
	if (p == NULL) {
		(void) sprintf(buf, "%s/%s/_pmtab is corrupt", HOME, tag);
		Saferrno = E_SAFERR;
		error(buf);
	}
	pp->p_id = p;

/*
 * get the first reserved field
 */

	p = nexttok(NULL, DELIM, FALSE);
	if (p == NULL) {
		(void) sprintf(buf, "%s/%s/_pmtab is corrupt", HOME, tag);
		Saferrno = E_SAFERR;
		error(buf);
	}
	pp->p_res1 = p;

/*
 * get the second reserved field
 */

	p = nexttok(NULL, DELIM, FALSE);
	if (p == NULL) {
		(void) sprintf(buf, "%s/%s/_pmtab is corrupt", HOME, tag);
		Saferrno = E_SAFERR;
		error(buf);
	}
	pp->p_res2 = p;

/*
 * get the third reserved field
 */

	p = nexttok(NULL, DELIM, FALSE);
	if (p == NULL) {
		(void) sprintf(buf, "%s/%s/_pmtab is corrupt", HOME, tag);
		Saferrno = E_SAFERR;
		error(buf);
	}
	pp->p_res3 = p;

/*
 * the rest is the port monitor specific info
 */

	p = nexttok(NULL, DELIM, TRUE);
	if (p == NULL) {
		(void) sprintf(buf, "%s/%s/_pmtab is corrupt", HOME, tag);
		Saferrno = E_SAFERR;
		error(buf);
	}
	pp->p_pmspec = p;
	return;
}


/*
 * pspec - format port monitor specific information
 *
 *	args:	spec - port monitor specific info, separated by
 *		       field separater character (may be escaped by \)
 */

char *
pspec(spec)
char *spec;
{
	static char buf[SIZE];		/* returned string */
	register char *from;		/* working pointer */
	register char *to;		/* working pointer */
	int newflag;			/* flag indicating new field */

	to = buf;
	from = spec;
	newflag = 1;
	while (*from) {
		switch (*from) {
		case ':':
			if (newflag) {
				*to++ = '-';
			}
			*to++ = ' ';
			from++;
			newflag = 1;
			break;
		case '\\':
			if (*(from + 1) == ':') {
				*to++ = ':';
				/* skip over \: */
				from += 2;
			}
			else
				*to++ = *from++;
			newflag = 0;
			break;
		default:
			newflag = 0;
			*to++ = *from++;
		}
	}
	*to = '\0';
	return(buf);
}


/*
 * pflags - put service flags into intelligible form for output
 *
 *	args:	flags - binary representation of flags
 *		dflag - true if a "-" should be returned if no flags
 */

char *
pflags(flags, dflag)
long flags;
int dflag;
{
	register int i;			/* scratch counter */
	static char buf[SIZE];		/* formatted flags */

	if (flags == 0) {
		if (dflag)
			return("-");
		else
			return("");
	}
	i = 0;
	if (flags & U_FLAG) {
		buf[i++] = 'u';
		flags &= ~U_FLAG;
	}
	if (flags & X_FLAG) {
		buf[i++] = 'x';
		flags &= ~X_FLAG;
	}
	if (flags) {
		Saferrno = E_SAFERR;
		error("Internal error in pflags");
	}
	buf[i] = '\0';
	return(buf);
}


/*
 * find_type - find entries in _sactab for a particular port monitor type
 *
 *	args:	fp - file pointer for _sactab
 *		type - type of port monitor we're looking for (if type is
 *		       null, it means find all PMs)
 */

struct taglist *
find_type(fp, type)
FILE *fp;
char *type;
{
	register char *p;			/* working pointer */
	struct sactab stab;			/* place to hold parsed info */
	register struct sactab *sp = &stab;	/* and a pointer to it */
	char buf[SIZE];				/* scratch buffer */
	struct taglist *thead;			/* linked list of tags */
	register struct taglist *temp;		/* scratch pointer */

	thead = NULL;
	while (fgets(buf, SIZE, fp)) {
		p = trim(buf);
		if (*p == '\0')
			continue;
		parse(p, sp);
		if ((type == NULL) || !(strcmp(sp->sc_type, type))) {
			temp = (struct taglist *) malloc(sizeof(struct taglist));
			if (temp == NULL) {
				Saferrno = E_SYSERR;
				error("malloc failed");
			}
			temp->t_next = thead;
			(void) strcpy(temp->t_tag, sp->sc_tag);
			(void) strcpy(temp->t_type, sp->sc_type);
			thead = temp;
		}
	}
	if (!feof(fp)) {
		Saferrno = E_SYSERR;
		error("error reading _sactab");
		/* NOTREACHED */
		return (0);
	} else
		return (thead ? thead : NULL);
}