cmds - zygaena/hammerhead

root / base / usr / src / cmd / devmgmt / cmds
cmds Plain Text 3425 lines 83.8 KB
#
# 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 2004 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# Copyright (c) 2018, Joyent, Inc.

include ../../Makefile.cmd

LIBADMDIR = ../../../lib/libadm/inc
CPPFLAGS += -I$(LIBADMDIR)
CFLAGS += $(CCVERBOSE)

PROG = devattr devreserv getvol putdgrp devfree getdev listdgrp getdgrp \
    putdev

LDLIBS += -ladm

CERRWARN += -Wno-parentheses
CERRWARN += $(CNOWARN_UNINIT)

SMOFF += signed

.KEEP_STATE:

.PARALLEL: $(PROG)

all: $(PROG)

clean:

install: all $(ROOTPROG)

lint: $(PROG:%=%.c)
	$(LINT.c) devattr.c	$(LDLIBS)
	$(LINT.c) devreserv.c	$(LDLIBS)
	$(LINT.c) getvol.c	$(LDLIBS)
	$(LINT.c) putdgrp.c	$(LDLIBS)
	$(LINT.c) devfree.c	$(LDLIBS)
	$(LINT.c) getdev.c	$(LDLIBS)
	$(LINT.c) listdgrp.c	$(LDLIBS)
	$(LINT.c) getdgrp.c	$(LDLIBS)
	$(LINT.c) putdev.c	$(LDLIBS)

FRC:

include ../../Makefile.targ
/*
 * 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   */

/*
 *  devattr.c
 *
 *  Contains the following:
 *	devattr		Command that returns [specific] attributes for
 *			a device.
 */

/*
 *  devattr [-v] device [attr [...]]
 *
 *	This command searches the device table file for the device specified.
 *	If it finds the device (matched either by alias or major and minor
 *	device number), it extracts the attribute(s) specified and writes
 *	that value to the standard output stream (stdout).
 *
 *	The command writes the values of the attributes to stdout one per
 *	line, in the order that they were requested.  If the -v option is
 *	requested, it writes the attributes in the form <attr>='<value>' where
 *	<attr> is the name of the attribute and <value> is the value of that
 *	attribute.
 *
 *  Returns:
 *	0	The command succeeded
 *	1	The command syntax is incorrect,
 *		An invalid option was used,
 *		An internal error occurred that prevented completion
 *	2	The device table could not be opened for reading.
 *	3	The requested device was not found in the device table
 *	4	A requested attribute was not defined for the device
 */

#include	<sys/types.h>
#include	<stdio.h>
#include	<string.h>
#include	<errno.h>
#include	<fmtmsg.h>
#include	<devmgmt.h>
#include	<devtab.h>
#include	<stdlib.h>


/*
 *  Local constant definitions
 *	TRUE		Boolean TRUE
 *	FALSE		Boolean FALSE
 */

#ifndef	TRUE
#define	TRUE	1
#endif

#ifndef	FALSE
#define	FALSE	0
#endif

/*
 *  Messages
 *	M_USAGE		Usage error
 *	M_ERROR		Unexpected internal error
 *	M_NODEV		Device not found in the device table
 *	M_NOATTR	Attribute not found
 *	M_DEVTAB	Can't open the device table
 */

#define	M_USAGE		"usage: devattr [-v] device [attribute [...]]"
#define	M_ERROR		"Internal error, errno=%d"
#define	M_NODEV		"Device not found in the device table: %s"
#define	M_NOATTR	"Attrubute not found: %s"
#define	M_DEVTAB	"Cannot open the device table: %s"


/*
 * Exit codes:
 *	EX_OK		All's well that ends well
 *	EX_ERROR	Some problem caused termination
 *	EX_DEVTAB	Device table could not be opened
 *	EX_NODEV	The device wasn't found in the device table
 *	EX_NOATTR	A requested attribute wasn't defined for the device
 */

#define	EX_OK 		0
#define	EX_ERROR	1
#define	EX_DEVTAB	2
#define	EX_NODEV	3
#define	EX_NOATTR	4


/*
 *  Macros
 *	stdmsg(r,l,s,t)	    Standard Message Generator
 *				r	Recoverability flag
 *				l	Standard Label
 *				s	Severity
 *				t	Text
 */

#define	stdmsg(r,l,s,t)	(void) fmtmsg(MM_PRINT|MM_UTIL|r,l,s,t,MM_NULLACT,MM_NULLTAG)


/*
 *  Local static data
 *	lbl	Buffer for the command label (for messages)
 *	txt		Buffer for the text of messages
 */

static char	lbl[MM_MXLABELLN+1];
static char	txt[MM_MXTXTLN+1];

/*
 *  main()
 *
 *	Implements the command "devattr".   This function parses the command
 *	line, then calls the devattr() function looking for the specified
 *	device and the requested attribute.  It writes the information to
 *	the standard output file in the requested format.
 *
 * Exits:
 *	0	The command succeeded
 *	1	The command syntax is incorrect,
 *		An invalid option was used,
 *		An internal error occurred that prevented completion
 *	2	The device table could not be opened for reading.
 *	3	The requested device was not found in the device table
 *	4	A requested attribute was not defined for the device
 */

int
main(int argc, char *argv[])
{

	/* Automatic data */
	char   *cmdname;		/* Pointer to command name */
	char   *device;			/* Pointer to device name */
	char   *attr;			/* Pointer to current attribute */
	char   *value;			/* Pointer to current attr value */
	char   *p;			/* Temporary character pointer */
	char  **argptr;			/* Pointer into argv[] list */
	int	syntaxerr;		/* TRUE if invalid option seen */
	int	noerr;			/* TRUE if all's well in processing */
	int	v_seen;			/* TRUE if -v is on the command-line */
	int	exitcode;		/* Value to return */
	int	severity;		/* Message severity */
	int	c;			/* Temp char value */


	/*
	 *  Parse the command-line.
	 */

	syntaxerr = FALSE;
	v_seen = FALSE;

	/* Extract options */
	opterr = FALSE;
	while ((c = getopt(argc, argv, "v")) != EOF) switch(c) {

	    /* -v option:  No argument, may be seen only once */
	    case 'v':
		if (!v_seen) v_seen = TRUE;
		else syntaxerr = TRUE;
		break;

	    /* Unknown option */
	    default:
		syntaxerr = TRUE;
	    break;
	}

	/* Build the command name */
	cmdname = argv[0];
	if ((p = strrchr(cmdname, '/')) != (char *) NULL) cmdname = p+1;
	(void) strlcat(strcpy(lbl, "UX:"), cmdname, sizeof(lbl));

	/* Make only the text-component of messages appear (remove this in SVR4.1) */
	(void) putenv("MSGVERB=text");

	/*
	 * Check for a usage error
	 *  - invalid option
	 *  - arg count < 2
	 *  - arg count < 3 && -v used
	 */

	if (syntaxerr || (argc < (optind+1))) {
	    stdmsg(MM_NRECOV, lbl, MM_ERROR, M_USAGE);
	    exit(EX_ERROR);
	}

	/* Open the device file (if there's one to be opened) */
	if (!_opendevtab("r")) {
	    if (p = _devtabpath()) {
		(void) snprintf(txt, sizeof(txt), M_DEVTAB, p);
		exitcode = EX_DEVTAB;
		severity = MM_ERROR;
	    } else {
		(void) sprintf(txt, M_ERROR, errno);
		exitcode = EX_ERROR;
		severity = MM_HALT;
	    }
	    stdmsg(MM_NRECOV, lbl, severity, txt);
	    exit(exitcode);
	}


	/*
	 *  Get the list of known attributes for the device.  This does
	 *  two things.  First, it verifies that the device is known in the
	 *  device table.  Second, it gets the attributes to list just in
	 *  case no attributes were specified.  Then, set a pointer to the
	 *  list of attributes to be extracted and listed...
	 */

	device = argv[optind];
	if ((argptr = listdev(device)) == (char **) NULL) {
	    if (errno == ENODEV) {
		(void) snprintf(txt, sizeof(txt), M_NODEV, device);
		exitcode = EX_NODEV;
		severity = MM_ERROR;
	    } else {
		(void) sprintf(txt, M_ERROR, errno);
		exitcode = EX_ERROR;
		severity = MM_HALT;
	    }
	    stdmsg(MM_NRECOV, lbl, severity, txt);
	    exit(exitcode);
	}
	if (argc > (optind+1)) argptr = &argv[optind+1];


	/*
	 *  List attributes.  If a requested attribute is not defined,
	 *  list the value of that attribute as null.  (Using shell
	 *  variables as the model for this.)
	 */

	exitcode = EX_OK;
	noerr = TRUE;
	while (noerr && ((attr = *argptr++) != (char *) NULL)) {
	    if (!(value = devattr(device, attr))) {
		if (errno == EINVAL) {
		    value = "";
		    (void) snprintf(txt, sizeof(txt), M_NOATTR, attr);
		    /* stdmsg(MM_RECOVER, lbl, MM_WARNING, txt); */
		    exitcode = EX_NOATTR;
		} else {
		    noerr = FALSE;
		    (void) sprintf(txt, M_ERROR, errno);
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, txt);
		    exitcode = EX_ERROR;
		}
	    }
	    if (noerr && v_seen) {
		(void) fputs(attr, stdout);
		(void) fputs("='", stdout);
		for (p = value ; *p ; p++) {
		    (void) putc(*p, stdout);
		    if (*p == '\'') (void) fputs("\"'\"'", stdout);
		}
		(void) fputs("'\n", stdout);
	    } else if (noerr) {
		(void) fputs(value, stdout);
		(void) putc('\n', stdout);
	    }
	}

	return (exitcode);
}
/*
 * 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 */

/*
 *	devfree key [device [...]]
 */

#include	<sys/types.h>
#include	<sys/param.h>
#include	<stdio.h>
#include	<errno.h>
#include	<stdlib.h>
#include	<string.h>
#include	<fmtmsg.h>
#include	<devmgmt.h>
#include	<values.h>
#include	<devtab.h>

/*
 *  Local definitions
 *	TRUE		Boolean TRUE value
 *	FALSE		Boolean FALSE value
 */
#ifndef		TRUE
#define		TRUE		('t')
#endif

#ifndef		FALSE
#define		FALSE		0
#endif


/*
 *  Exit codes:
 *	EX_OK		Exit code for all went well
 *	EX_ERROR	Exit code for something failed
 *	EX_TBLERR	Exit code for errors relating to device or lock tables
 *	EX_NOFREE	Exit code for free failed
 */

#define		EX_OK		0
#define		EX_ERROR	1
#define		EX_TBLERR	2
#define		EX_NOFREE	3


/*
 * Messages
 *	M_USAGE		Usage error
 *	M_INVKEY	Invalid key specified
 *	M_NOTRSVD	Attempting to free something not alloc'd
 *	M_NOTONKEY	Attempting to free with wrong key
 *	M_DEVTAB	Error opening the device table
 *	M_RSVTAB	Error opening the device-reservation table
 *	M_ERROR		Some internal error
 */

#define		M_USAGE		"usage: devfree key [device [...]]"
#define		M_INVKEY	"Invalid key: %s"
#define		M_NOTRSVD	"Device not reserved: %s"
#define		M_NOTONKEY	"Cannot unreserve device: %s"
#define		M_DEVTAB	"Cannot open the device table: %s"
#define		M_RSVTAB	"Cannot open the device-reservation table: %s"
#define		M_ERROR		"Internal error, errno=%d"


/*
 *  Local functions and static data
 *	stdmsg(r,l,s,m)		Macro for standard message generation
 *				r	MM_NRECOV or MM_RECOV (recoverability)
 *				l	Label
 *				s	Severity
 *				m	Message
 *	lbl			Buffer for the label-component of a message.
 *	msg			Buffer for the text-component of a message.
 */

#define	stdmsg(r, l, s, m)	\
	(void) fmtmsg(MM_PRINT | MM_UTIL | r, l, s, m, MM_NULLACT, MM_NULLTAG)

static	char	lbl[MM_MXLABELLN+1];
static	char	msg[MM_MXTXTLN+1];

/*
 *  devfree key [device [device [...]]]
 *
 *	This command frees devices that have been reserved using
 *	the devreserv command (or the devreserv() function).
 *
 *  Options:  None
 *
 *  Arguments:
 *	key		The key on which the device to free was allocated on.
 *			If omitted, all keys are assumed.
 *	device		The device to free.  If omitted, all devices allocated
 *			using the key are freed.
 *
 *  Command Values:
 *	EX_OK		0	Device(s) successfully freed
 *	EX_ERROR	1	A syntax error or other error occurred
 *	EX_TBLERR	2	A problem with device management tables
 *	EX_NOFREE	3	A requested device couldn't be freed
 */

int
main(int argc, char *argv[])
{
	/* Automatics */
	char			**argp;		/* Ptr to current argument */
	struct reservdev	**rsvd;		/* Ptr to list of locks */
	struct reservdev	**plk;		/* Running ptr to locks */
	char			*devtab;	/* Ptr to device table name */
	char			*rsvtab;	/* Ptr to dev-rsv-tbl name */
	char			*p;		/* Temp char pointer */
	int			argcount;	/* Number of args on cmd */
	long			lkey;		/* Key for locking (long) */
	int			key;		/* Key for locking */
	int			halt;		/* TRUE if we need to stop */
	int			sev;		/* Message severity */
	int			exitcode;	/* Value of command */
	int			syntaxerr;	/* Flag, TRUE if syntax error */
	int			exitcd;		/* Value for exit() */
	int			c;		/* Option character */
	const char		*errstr;


	/*
	 * Initializations
	 */

	/* Build a message label */
	if (p = strrchr(argv[0], '/'))
		p++;
	else
		p = argv[0];
	(void) strlcat(strcpy(lbl, "UX:"), p, sizeof (lbl));

	/*
	 * Make only the text component of messages appear
	 * (remove this in SVR4.1)
	 */
	(void) putenv("MSGVERB=text");


	/*
	 * Parse the options from the command line
	 */

	opterr = 0;
	syntaxerr = FALSE;
	while ((c = getopt(argc, argv, "")) != EOF) {
		switch (c) {
		default:
			syntaxerr = FALSE;
			break;
		}
	}


	/* Argument initializations */
	argp = &argv[optind];
	if ((argcount = argc-optind) < 1)
		syntaxerr = TRUE;


	/* If there's (an obvious) syntax error, write a message and quit */
	if (syntaxerr) {
		stdmsg(MM_NRECOV, lbl, MM_ERROR, M_USAGE);
		exit(EX_ERROR);
	}


	/*
	 *  devfree key
	 *
	 *	Free all devices that have been reserved using the key "key".
	 */

	if (argcount == 1) {

		/* Extract the key from the command */
		lkey = strtonum(*argp, 1, MAXINT, &errstr);
		if (errstr != NULL) {
			(void) snprintf(msg, sizeof (msg), M_INVKEY, *argp);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exit(EX_ERROR);
		}
		key = (int)lkey;

		/* Get the list of devices currently reserved */
		if (rsvd = reservdev()) {
			exitcd = EX_OK;
			for (plk = rsvd; *plk; plk++) {
				if ((*plk)->key == key)
					if (devfree(key, (*plk)->devname) != 0)
						exitcd = EX_NOFREE;
			}
		} else {
			if (((errno == ENOENT) || (errno == EACCES)) &&
			    (rsvtab = _rsvtabpath())) {
				(void) snprintf(msg, sizeof (msg), M_RSVTAB,
				    rsvtab);
				exitcd = EX_TBLERR;
				sev = MM_ERROR;
			} else {
				(void) snprintf(msg, sizeof (msg), M_ERROR,
				    errno);
				exitcd = EX_ERROR;
				sev = MM_HALT;
			}
			stdmsg(MM_NRECOV, lbl, sev, msg);
		}

		/* Done */
		exit(exitcd);
	}


	/*
	 *  devfree key device [...]
	 *
	 *	Free specific devices
	 */

	/* Open the device file (if there's one to be opened) */
	if (!_opendevtab("r")) {
		if (devtab = _devtabpath()) {
			(void) snprintf(msg, sizeof (msg), M_DEVTAB, devtab);
			exitcd = EX_TBLERR;
			sev = MM_ERROR;
		} else {
			(void) snprintf(msg, sizeof (msg), M_ERROR, errno);
			exitcd = EX_ERROR;
			sev = MM_HALT;
		}
		stdmsg(MM_NRECOV, lbl, sev, msg);
		exit(exitcd);
	}

	/* Extract the key from the command */
	lkey = strtonum(*argp, 1, MAXINT, &errstr);
	if (errstr != NULL) {
		(void) snprintf(msg, sizeof (msg), M_INVKEY, *argp);
		stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		exit(EX_ERROR);
	}
	key = (int)lkey;
	argp++;

	/* Loop through the list of devices to free */
	exitcode = EX_OK;
	halt = FALSE;
	while (!halt && *argp) {

		/* Try to free the device */
		if (devfree(key, *argp) != 0) {
			if ((errno == EACCES) || (errno == ENOENT)) {

				/* Can't get at reservation file */
				if (rsvtab = _rsvtabpath()) {
					exitcode = EX_TBLERR;
					(void) snprintf(msg, sizeof (msg),
					    M_RSVTAB, rsvtab);
					sev = MM_ERROR;
				} else {
					exitcode = EX_ERROR;
					(void) snprintf(msg, sizeof (msg),
					    M_ERROR, errno);
					sev = MM_HALT;
				}
				stdmsg(MM_NRECOV, lbl, sev, msg);
				halt = TRUE;
			} else if (errno == EPERM) {

				/* Wrong key */
				(void) snprintf(msg, sizeof (msg), M_NOTONKEY,
				    *argp);
				stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
				exitcode = EX_NOFREE;
			} else if (errno == EINVAL) {

				/* Device not reserved */
				(void) snprintf(msg, sizeof (msg), M_NOTRSVD,
				    *argp);
				stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
				exitcode = EX_NOFREE;
			} else {

				/* Some other strange error occurred */
				(void) snprintf(msg, sizeof (msg), M_ERROR,
				    errno);
				stdmsg(MM_NRECOV, lbl, MM_HALT, msg);
				exitcode = EX_ERROR;
				halt = TRUE;
			}
		}
		argp++;
	}

	/* Exit with the appropriate code */
	return (exitcode);
}
/*
 * 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 */

#include	<sys/types.h>
#include	<sys/param.h>
#include	<stdio.h>
#include	<errno.h>
#include	<stdlib.h>
#include	<string.h>
#include	<fmtmsg.h>
#include	<devmgmt.h>
#include	<devtab.h>
#include	<values.h>

/*
 *  Local definitions
 *	TRUE		Boolean TRUE value
 *	FALSE		Boolean FALSE value
 *	TOKDELIMS	Char string of delimiters for lists
 */

#ifndef		TRUE
#define		TRUE		('t')
#endif

#ifndef		FALSE
#define		FALSE		0
#endif

#define		TOKDELIMS	", \t\n"


/*
 *  Exit codes:
 *	EX_OK		Exit code for all went well
 *	EX_ERROR	Exit code for something failed
 *	EX_TABLES	A table couldn't be accessed
 *	EX_NOALLOC	Exit code for allocation failed
 */

#define		EX_OK		0
#define		EX_ERROR	1
#define		EX_TABLES	2
#define		EX_NOALLOC	3

/*
 *  Messages:
 *	M_USAGE		Usage error
 *	M_INVKEY	Invalid key specified
 *	M_ERROR		Some strange error
 *	M_UNABLE	A list of devices is unavailable
 *	M_DEVTAB	Can't access device table (for reading)
 *	M_RSVTAB	Can't access device reservation table (for r/w)
 *	M_NODEV		A list of devices is invalid
 */

#define	M_USAGE		"usage: devreserv [key [devicelist [...]]]"
#define	M_INVKEY	"Invalid key: %s"
#define	M_ERROR		"Internal error, errno=%d"
#define	M_UNABLE	"Cannot reserve devices"
#define	M_DEVTAB	"Cannot open the device table: %s"
#define	M_RSVTAB	"Cannot open the device-reservation table: %s"
#define	M_NODEV		M_UNABLE


/*
 *  Local functions and static data
 *
 *	buildreqlist()	Builds the list of requested devices for devreserv()
 *	freereqlist()	Free space allocated to the list of requested devices
 *	ndevsin()	Get number of elements in a list
 *	stdmsg(r,l,s,m)	Standard message generation
 *			r	Recoverability flag
 *			l	Label
 *			s	Severity
 *			m	Message
 *
 *	lbl		Buffer for the label-component of a message
 *	txt		Buffer for the text-component of a message
 */

static char  ***buildreqlist();
static void	freereqlist();
static int	ndevsin();

#define	stdmsg(r, l, s, m)	\
	(void) fmtmsg(MM_PRINT | MM_UTIL | r, l, s, m, MM_NULLACT, MM_NULLTAG)

static	char	lbl[MM_MXLABELLN+1];
static	char	txt[MM_MXTXTLN+1];

/*
 *  devreserv [key [devlist [devlist [...]]]]
 *
 *	This command reserves sets of devices known to the OA&M device
 *	management system.  It reserves a device from each of the device
 *	lists presented to it, reserving them on the key (<key>).  If no
 *	device-lists are provided, the command lists those devices reserved
 *	on the given key (<key>).  If no key (<key>) is provided, the
 *	command lists all devices currently reserved.
 *
 *  Options:  None
 *
 *  Arguments:
 *	key		Key to lock the devices on
 *	devlist		A comma-, space-, or tab-list containing devices
 *			(pathnames or aliases).  For typical shells, space-
 *			and tab-lists should be quoted or the separator should
 *			be somehow escaped.
 *
 *  Command Values:
 *	EX_OK		0	Device(s) successfully allocated
 *	EX_ERROR	1	A syntax or other error occurred
 *	EX_TABLES	2	Either the device-table or the device-
 *				reservation table couldn't be opened as needed
 *	EX_NOALLOC	3	The device-reservation request couldn't be
 *				fulfilled.
 */

int
main(int argc, char *argv[])
{

	/* Automatics */
	char			***reqlist;	/* * to list of lists */
	char			**argp;		/* Ptr to current argument */
	char			**alloclist;	/* List of allocated devices */
	char			**pp;		/* Temp ptr to char ptrs */
	struct reservdev	**rsvd;		/* Ptr to list of rsvd devs */
	struct reservdev	**plk;		/* Running ptr to locks */
	char			*p;		/* Temp char ptr */
	char			*devtab;	/* Device table pathname */
	char			*rsvtab;	/* Dev-rsv tbl pathname */
	int			argcount;	/* Number of args on cmd */
	long			lkey;		/* Key for locking (long) */
	int			key;		/* Key for locking */
	int			exitcode;	/* Value to return */
	int			sev;		/* Message severity */
	int			syntaxerr;	/* Flag, TRUE if syntax error */
	int			c;		/* Option character */
	int			i;		/* Temp counter */
	const char		*errstr;


	/*
	 * Initializations
	 */

	/* Build a message label */
	if (p = strrchr(argv[0], '/')) p++;
	else p = argv[0];
	(void) strlcat(strcpy(lbl, "UX:"), p, sizeof (lbl));


	/*
	 * Allow only the text component of messages to be written
	 * (this will probably go away in SVR4.1)
	 */

	(void) putenv("MSGVERB=text");


	/*
	 * Parse the options from the command line
	 */

	opterr = 0;
	syntaxerr = FALSE;
	while ((c = getopt(argc, argv, "")) != EOF)
		switch (c) {
		default:
			syntaxerr = FALSE;
			break;
		}

	/* If there's (an obvious) syntax error, write a message and quit */
	if (syntaxerr) {
		stdmsg(MM_NRECOV, lbl, MM_ERROR, M_USAGE);
		exit(EX_ERROR);
	}

	/* Argument initializations */
	argcount = argc - optind;
	argp = &argv[optind];


	/*
	 *  devreserv
	 *
	 *	If euid == 0, write a list of all currently allocated devices.
	 */

	if (argcount == 0) {

		/* Get the list of reserved devices */
		if (rsvd = reservdev()) {

			/*
			 * Write the list of reserved devices with the key
			 * that the device was locked on.  The key should go
			 * in column 16, but separate it from the alias with at
			 * least one space
			 */

			exitcode = EX_OK;
			for (plk = rsvd; *plk; plk++) {
				if ((i = fputs((*plk)->devname, stdout)) >= 0)
					do {
						(void) fputc(' ', stdout);
					} while (++i < 16);
				(void) fprintf(stdout, "%ld\n", (*plk)->key);
			}

		} else {

			/* Problems getting the list of reserved devices */
			if (((errno == EINVAL) || (errno == EACCES)) &&
			    (rsvtab = _rsvtabpath())) {
				(void) snprintf(txt, sizeof (txt), M_RSVTAB,
				    rsvtab);
				exitcode = EX_TABLES;
				sev = MM_ERROR;
			} else {
				(void) sprintf(txt, M_ERROR, errno);
				exitcode = EX_ERROR;
				sev = MM_HALT;
			}
			stdmsg(MM_NRECOV, lbl, sev, txt);
		}

		/* Finished */
		exit(exitcode);
	}


	/*
	 *  devreserv key
	 *
	 *	Generate a list of the devices allocated on a specific key.
	 */

	if (argcount == 1) {

		/* Extract the key from the command */
		lkey = strtonum(*argp, 1, MAXINT, &errstr);
		if (errstr != NULL) {

			/* <key> argument invalid */
			(void) snprintf(txt, sizeof (txt), M_INVKEY, *argp);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, txt);
			exitcode = EX_ERROR;

		} else {

			key = (int)lkey;

			/* Get the list of reserved devices ... */
			if (rsvd = reservdev()) {

				/*
				 * For each reserved device, write the alias
				 * to stdout
				 */
				exitcode = EX_OK;
				for (plk = rsvd; *plk; plk++) {
					if ((*plk)->key == key)
						(void) puts((*plk)->devname);
				}

			} else {

				/*
				 * Problems getting the list of reserved
				 * devices
				 */
				if (((errno == EINVAL) || (errno == EACCES)) &&
				    (rsvtab = _rsvtabpath())) {
					(void) snprintf(txt, sizeof (txt),
					    M_RSVTAB, rsvtab);
					exitcode = EX_TABLES;
					sev = MM_ERROR;
				} else {
					(void) sprintf(txt, M_ERROR, errno);
					exitcode = EX_ERROR;
					sev = MM_HALT;
				}
				stdmsg(MM_NRECOV, lbl, sev, txt);
			}
		}

		/* Finished */
		exit(exitcode);
	}


	/*
	 *  devreserv key devlist [...]
	 *
	 *	Reserve specific devices
	 */

	/* Open the device file (if there's one to be opened) */
	if (!_opendevtab("r")) {
		if (devtab = _devtabpath()) {
			(void) snprintf(txt, sizeof (txt), M_DEVTAB, devtab);
			exitcode = EX_TABLES;
			sev = MM_ERROR;
		} else {
			(void) sprintf(txt, M_ERROR, errno);
			exitcode = EX_ERROR;
			sev = MM_HALT;
		}
		stdmsg(MM_NRECOV, lbl, sev, txt);
		exit(exitcode);
	}

	/* Extract the key from the command */
	lkey = strtonum(*argp, 1, MAXINT, &errstr);
	if (errstr != NULL) {
		(void) snprintf(txt, sizeof (txt), M_INVKEY, *argp);
		stdmsg(MM_NRECOV, lbl, MM_ERROR, txt);
		exit(EX_ERROR);
	}

	key = (int)lkey;
	argp++;

	/* Build the device request list from the command arguments */
	if (reqlist = buildreqlist(argp)) {

		/* Attempt to allocate the devices */
		if (alloclist = devreserv(key, reqlist)) {

			/*
			 * For each allocated device, write the alias to stdout
			 * and free the space allocated for the string.
			 */

			for (pp = alloclist; *pp; pp++) {
				(void) puts(*pp);
				free(*pp);
			}

			/* Free the list of allocated devices */
			free(alloclist);
			exitcode = EX_OK;
		} else {
			/* Device allocation failed */
			if (errno == EAGAIN) {
				stdmsg(MM_NRECOV, lbl, MM_ERROR, M_UNABLE);
				exitcode = EX_NOALLOC;
			} else if (errno == ENODEV) {
				stdmsg(MM_NRECOV, lbl, MM_ERROR, M_NODEV);
				exitcode = EX_NOALLOC;
			} else {
				(void) sprintf(txt, M_ERROR, errno);
				stdmsg(MM_NRECOV, lbl, MM_HALT, txt);
				exitcode = EX_ERROR;
			}
		}
		freereqlist(reqlist);
	}


	/* Exit with the appropriate code */
	return (exitcode);
}

/*
 * char ***buildreqlist(args)
 *	char   **args
 *
 *	Build the list of lists of devices to request, as described by the
 *	arguments on the command line.
 *
 *  Arguments:
 *	char **args	The address of the first argument of the list of
 *			lists of devices to allocate.   (This list is
 *			terminated with a (char *) NULL.)
 *
 *  Returns:  char ***
 *	A pointer to a list containing addresses of lists of pointers to
 *	character-strings, as expected by "devreserv()"
 *
 *  Notes:
 *    -	Assuming that strtok() won't return "".  If it does, the
 *	parsing algorithm needs to be enhanced a bit to eliminate
 *	these cases.
 */

static char ***
buildreqlist(char **args)
{
	/* Local automatic data */
	char		***addrlist;	/* Addr of space for ptrs to lists */
	char		***ppp;		/* Pointer to pointers to pointers */
	char		**pp;		/* Pointer to pointers */
	char		**qq;		/* Pointer to pointers */
	int		noerror;	/* FLAG, TRUE if all's well */
	int		i;		/* Counter */
	int		n;		/* Another counter */


	/* Count the number of lists we have to work with */
	i = 1;
	for (pp = args; *pp; pp++)
		i++;


	/* If we can allocate space for the list of lists ... */
	if (addrlist = malloc(i * sizeof (char **))) {

		/* Parse each list, putting that list in the list of lists */
		ppp = addrlist;
		noerror = TRUE;
		for (pp = args; noerror && *pp; pp++) {
			n = ndevsin(*pp, TOKDELIMS);
			if (*ppp = malloc((n + 1) * sizeof (char *))) {
				qq = *ppp++;
				if (*qq++ = strtok(*pp, TOKDELIMS))
					while (*qq++ = strtok(NULL, TOKDELIMS))
						;
			} else {
				noerror = FALSE;
			}
		}

		/* If there was an error, clean up the malloc()s we've made */
		if (!noerror) {
			freereqlist(addrlist);
			addrlist = NULL;
		}
	}

	/* Return ptr to the list of addresses of lists (or NULL if none) */
	return (addrlist);
}

/*
 *  void freereqlist(list)
 *	char ***list
 *
 *	This function frees the space allocated to the list of lists
 *	referenced by <list>
 *
 *  Arguments:
 *	char ***list	Address of the list of lists
 *
 *  Returns:  void
 */

static void
freereqlist(char ***list)
{
	char ***ppp;
	if (list) {
		for (ppp = list; *ppp; ppp++)
			free(*ppp);
		free(list);
	}
}

/*
 * int ndevsin(list, delims)
 *	char   *list
 *	char   *delims
 *
 *	This function determines how many tokens are in the list <list>.
 *	The tokens are delimited by fields of characters in the string
 *	<delims>.  It returns the number of tokens in the list.
 *
 *  Arguments:
 *	char *list	The <delims>list of tokens to scan
 *	char *delims	The list of delimiters that define the list
 *
 *  Returns: int
 *	The number of elements in the list.
 *
 *  Notes:
 *    -	This function does not recognize "null" elements.  For example,
 *	a,b,,,,c,,d contains 4 elememts (if delims contains a ',')
 */

static int
ndevsin(char *list, char *delims)
{
	char   *p;			/* Running character pointer */
	int	count;			/* Number of tokens seen so far */
	int	tokflag;		/* TRUE if we're parsing a token */

	count = 0;			/* None seen yet */
	tokflag = FALSE;		/* Not in a token */

	/* Scan the character-string containing the list of tokens */
	for (p = list; *p; p++) {

		/* If a delimiter, we're not in a token */
		if (strchr(delims, *p)) {
			tokflag = FALSE;

		} else if (!tokflag) {
			/*
			 * Otherwise, if we weren't in a token,
			 * we've found one
			 */
			tokflag = TRUE;
			count++;
		}
	}

	/* Return the number of elements in the list */
	return (count);
}
/*
 * 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   */

/*
 *  getdev.c
 *
 *  Contains
 *	getdev	Writes on the standard output stream a list of devices
 *		that match certain criteria.
 */
#include	<sys/types.h>
#include	<stdio.h>
#include	<errno.h>
#include	<stdlib.h>
#include	<string.h>
#include	<fmtmsg.h>
#include	<devmgmt.h>
#include	<devtab.h>


/*
 *  Local Definitions
 *	TRUE		Boolean TRUE value
 *	FALSE		Boolean FALSE value
 *	EX_OK		Exit Value if all went well
 *	EX_ERROR	Exit Value if an error occurred
 *	EX_DEVTAB	Exit Value if the device table couldn't be opened

 */

#ifndef	TRUE
#define	TRUE		(1)
#endif

#ifndef	FALSE
#define FALSE		(0)
#endif

#define	EX_OK		0
#define	EX_ERROR	1
#define	EX_DEVTAB	2


/*
 *  Messages:
 *	M_USAGE		Usage error
 *	M_DEVTAB	Can't open the device table
 *	M_NODEV		Device not found in the device table
 *	M_ERROR		Unexpected or internal error
 */

#define	M_USAGE		"usage: getdev [-ae] [criterion [...]] [device [...]]"
#define	M_DEVTAB	"Cannot open the device table: %s"
#define	M_NODEV		"Device not found in the device table: %s"
#define	M_ERROR		"Internal error, errno=%d"


/*
 *  Local (Static) Definitions and macros
 *	buildcriterialist()	Builds the criteria list from the command-line
 *	builddevlist()		Builds the device list from the command-line
 *	lbl			Buffer for the standard message label
 *	txt			Buffer for the standard message text
 *	stdmsg(r,l,s,t)		Write a standard message:
 *				    r	Recoverability flag
 *				    l	Standard label
 *				    s	Severity
 *				    t	Text
 */

static	char  **buildcriterialist();
static	char  **builddevlist();

static	char	lbl[MM_MXLABELLN+1];
static	char	txt[MM_MXTXTLN+1];

#define	stdmsg(r,l,s,t)	(void) fmtmsg(MM_PRINT|MM_UTIL|r,l,s,t,MM_NULLACT,MM_NULLTAG)

/*
 *  getdev [-ae] [criterion [...]] [device [...]]
 *
 *	This command generates a list of devices that match the
 *	specified criteria.
 *
 *  Options:
 *	-a		A device must meet all of the criteria to be
 *			included in the generated list instead of just
 *			one of the criteria (the "and" flag)
 *	-e		Exclude the devices mentioned from the generated
 *			list.  If this flag is omitted, the devices in the
 *			list are selected from the devices mentioned.
 *
 *  Arguments:
 *	criterion	An <attr><op><value> expression that describes
 *			a device attribute.
 *			<attr>	is a device attribute
 *			<op> 	may be = != : !: indicating equals, does not
 *				equal, is defined, and is not defined
 *				respectively
 *			<value>	is the attribute value.  Currently, the only
 *				value supported for the : and !: operators
 *				is *
 *	device		A device to select for or exclude from the generated
 *			list
 *
 *  Exit values:
 *	EX_OK		All went well
 *	EX_ERROR	An error (syntax, internal, or resource) occurred
 *	EX_DEVTAB	The device-table could not be opened for reading
 */

int
main(int argc, char **argv)
{

	/*
	 *  Automatic data
	 */

	char	      **arglist;	/* List of arguments */
	char	      **criterialist;	/* List of criteria */
	char	      **devicelist;	/* List of devices to search/ignore */
	char	      **fitdevlist;	/* List of devices that fit criteria */
	char	       *cmdname;	/* Simple command name */
	char	       *device;		/* Device name in the list */
	char	       *devtab;		/* The device table name */
	int		exitcode;	/* Value to return to the caller */
	int		sev;		/* Message severity */
	int		optchar;	/* Option character (from getopt()) */
	int		andflag;	/* TRUE if criteria are to be anded */
	int		excludeflag;	/* TRUE if exclude "devices" lists */
	int		options;	/* Options to pass to getdev() */
	int		usageerr;	/* TRUE if syntax error */


	/* Build the message label from the (simple) command name */
	if ((cmdname = strrchr(argv[0], '/')) != (char *) NULL) cmdname++;
	else cmdname = argv[0];
	(void) strlcat(strcpy(lbl, "UX:"), cmdname, sizeof(lbl));

	/* Write text-component of messages only (goes away in SVR4.1) */
	(void) putenv("MSGVERB=text");

	/*
	 *  Parse the command line:
	 *	- Options
	 *	- Selection criteria
	 *	- Devices to include or exclude
	 */

	/*
	 *  Extract options from the command line
	 */

	/* Initializations */
	andflag = FALSE;	/* No -a -- Or criteria data */
	excludeflag = FALSE;	/* No -e -- Include only mentioned devices */
	usageerr = FALSE;	/* No errors on the command line (yet) */

	/*
	 *  Loop until all of the command line options have been parced
	 */
	opterr = FALSE;			/* Don't let getopt() write messages */
	while ((optchar = getopt(argc, argv, "ae")) != EOF) switch (optchar) {

	/* -a  List devices that fit all of the criteria listed */
	case 'a':
	    if (andflag) usageerr = TRUE;
	    else andflag = TRUE;
	    break;

	/* -e  Exclude those devices mentioned on the command line */
	case 'e':
	    if (excludeflag) usageerr = TRUE;
	    else excludeflag = TRUE;
	    break;

	/* Default case -- command usage error */
	case '?':
	default:
	    usageerr = TRUE;
	    break;
	}

	/* If there is a usage error, write an appropriate message and exit */
	if (usageerr) {
	    stdmsg(MM_NRECOV, lbl, MM_ERROR, M_USAGE);
	    exit(EX_ERROR);
	}

	/* Open the device file (if there's one to be opened) */
	if (!_opendevtab("r")) {
	    if (devtab = _devtabpath()) {
		(void) snprintf(txt, sizeof(txt), M_DEVTAB, devtab);
		sev = MM_ERROR;
		exitcode = EX_DEVTAB;
	    } else {
		(void) sprintf(txt, M_ERROR, errno);
		sev = MM_HALT;
		exitcode = EX_ERROR;
	    }
	    stdmsg(MM_NRECOV, lbl, sev, txt);
	    exit(exitcode);
	}

	/* Build the list of criteria and devices */
	arglist = argv + optind;
	criterialist = buildcriterialist(arglist);
	devicelist = builddevlist(arglist);
	options = (excludeflag?DTAB_EXCLUDEFLAG:0)|(andflag?DTAB_ANDCRITERIA:0);

	/*
	 *  Get the list of devices that meets the criteria requested.  If we
	 *  got a list (that might be empty), write that list to the standard
	 *  output file (stdout).
	 */

	exitcode = 0;
	if (!(fitdevlist = getdev(devicelist, criterialist, options))) {
	    exitcode = 1;
	}
	else for (device = *fitdevlist++ ; device ; device = *fitdevlist++)
		(void) puts(device);

	/* Finished */
	return(exitcode);
}

/*
 *  char **buildcriterialist(arglist)
 *	char  **arglist
 *
 *	Build a list of pointers to the criterion on the command-line
 *
 *  Arguments:
 *	arglist		The list of arguments on the command-line
 *
 *  Returns:  char **
 *	The address of the first item of the list of criterion on the
 *	command-line.  This is a pointer to malloc()ed space.
 */

static char  **
buildcriterialist(arglist)
	char  **arglist;	/* Pointer to the list of argument pointers */
{
	/*
	 *  Automatic data
	 */

	char  **pp;			/* Pointer to a criteria */
	char  **allocbuf;		/* Pointer to the allocated data */
	int	ncriteria;		/* Number of criteria found */


	/*
	 *  Search the argument list, looking for the end of the list or
	 *  the first thing that's not a criteria.  (A criteria is a
	 *  character-string that contains a colon (':') or an equal-sign ('=')
	 */

	pp = arglist;
	ncriteria = 0;
	while (*pp && (strchr(*pp, '=') || strchr(*pp, ':'))) {
	    ncriteria++;
	    pp++;
	}

	if (ncriteria > 0) {

	    /* Allocate space for the list of criteria pointers */
	    allocbuf = (char **) malloc((ncriteria+1)*sizeof(char **));

	    /*
	     *  Build the list of criteria arguments
	     */
	    pp = allocbuf;	/* Beginning of the list */
	    while (*arglist &&			/* If there's more to do ... */
		   (strchr(*arglist, '=') ||	/* and it's a = criterion ... */
		    strchr(*arglist, ':')))	/* or it's a : criterion ... */
			*pp++ = *arglist++;	/* Include it in the list */
	    *pp = (char *) NULL;	/* Terminate the list */

	} else allocbuf = (char **) NULL;	/* NO criteria */


	return (allocbuf);
}

/*
 *  char **builddevlist(arglist)
 *	char  **arglist
 *
 *	Builds a list of pointers to the devices mentioned on the command-
 *	line and returns the address of that list.
 *
 *  Arguments:
 *	arglist		The address of the list of arguments to the
 *			getdev command.
 *
 *  Returns:  char **
 *	A pointer to the first item in the list of pointers to devices
 *	specified on the command-line
 */

static char  **
builddevlist(arglist)
	char  **arglist;	/* Pointer to the list of pointers to args */
{
	/*
	 *  Automatic data
	 */

	/*
	 *  Search the argument list, looking for the end of the list or the
	 *  first thing that's not a criteria.  It is the first device in the
	 *  list of devices (if any).
	 */

	while (*arglist && (strchr(*arglist, '=') || strchr(*arglist, ':'))) arglist++;

	/* Return a pointer to the argument list. */
	return(*arglist?arglist:(char **) NULL);
}
/*
 * 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  	*/

/*
 *  Implements the main body of the "getdgrp" command.
 */
#include	<sys/types.h>
#include	<stdio.h>
#include	<errno.h>
#include	<stdlib.h>
#include	<string.h>
#include	<devmgmt.h>
#include	<devtab.h>
#include	<fmtmsg.h>


/*
 *  Local Definitions
 *	TRUE		Boolean TRUE value
 *	FALSE		Boolean FALSE value
 *	NULL		Null address
 */

#ifndef	TRUE
#define	TRUE	1
#endif

#ifndef	FALSE
#define FALSE	0
#endif


/*
 * Exit codes:
 *	EX_OK		All's well that ends well
 *	EX_ERROR	Some other error occurred
 *	EX_DTAB		Device table couldn't be opened
 *	EX_DGRP		Device-group table couldn't be open.
 */

#define	EX_OK		0
#define	EX_ERROR	1
#define	EX_DTAB		2
#define	EX_DGRP		2


/*
 *  Messages:
 *	M_USAGE		Command usage error
 *	M_ERROR		Some unexpected error
 *	M_DEVTAB	Device table couldn't be opened
 *	M_DGROUP	Device-group table couldn't be opened
 */

#define	M_USAGE		"usage: getdgrp [-ael] [criterion [...]] [dgroup [...]]"
#define	M_ERROR		"Internal error, errno=%d"
#define	M_DEVTAB	"Cannot open the device table: %s"
#define	M_DGROUP	"Cannot open the device-group table: %s"


/*
 *  Internal References
 *	buildcriterialist()	Builds a list of the criteria on the
 *				command line
 *	buildgrouplist()	Builds a list of the device-groups mentioned
 *				on the command line
 */

static	char  **buildcriterialist();	/* Builds criteria list from command line */
static	char  **builddgrouplist();	/* Builds dgroup list from command line */


/*
 *  Macros
 *	stdmsg(r,l,s,t)	    Generate a standard message
 *				r	Recoverability flag
 *				l	Standard label
 *				s	Severity
 *				t	Text
 *	isacriterion(p)	    Returns TRUE if *p is a criterion, FALSE otherwise
 */

#define	stdmsg(r,l,s,t)	(void) fmtmsg(MM_PRINT|MM_UTIL|r,l,s,t,MM_NULLACT,MM_NULLTAG)
#define	isacriterion(p)	(strchr(*arglist,'=')||strchr(*arglist,':'))


/*
 *  Static Variables
 *	lbl		Buffer for standard message label
 *	txt		Buffer for standard message text
 */

static	char	lbl[MM_MXLABELLN+1];
static	char	txt[MM_MXTXTLN+1];

/*
 *  getdgrp [-ael] [criterion [...]] [dgroup [...]]
 *
 *	This function gets the device groups that contain as members devices
 *	that match the given criteria.
 *
 *  Options:
 *	-a	A device must meet all criteria before the device-group in
 *		which it is a member can be selected for inclusion in the
 *		generated list.  If this option is missing, a device must
 *		meet at least one criterion before it's group can be
 *		selected.  This option has no affect if there are no criterion
 *		on the command-line.
 *	-e	The list of device groups specifies groups to exclude from
 *		the generated list.  If this option is omitted, the list
 *		of groups is the set of groups that can be selected.  This
 *		option has no effect if there are no device-groups on the
 *		command-line.
 *	-l	List all device groups, even those that have no valid
 *		members (this option has no effect if criterion are specified
 *
 *  Arguments:
 *	criterion	A device criterion of the form <attr><op><val> where
 *			<attr> is the name of an attribute, <op> is "=", "!=",
 *			":", or "!:" for "is equal to", "is not equal to",
 *			"is defined," or "is not defined."  <val> is the value
 *			that the attribute must be equal to or not equal to.
 *			(<val> must be "*" if <op> is ":" or "!:").
 *	dgroup		A device group that is to be exclude selected for the
 *			generated list or excluded from the the generated
 *			list.
 *
 *  Exit values:
 *	0	Success
 *	1	Usage or an internal error
 *	2	The device table or the device-group table could not be
 *		opened for reading
 */

int
main(int argc, char **argv)
{

	/*
	 *  Automatic data
	 */

	char  **arglist;	/* List of arguments (subset of argv) */
	char  **criterialist;	/* List of criteria */
	char  **dgrouplist;	/* List of device groups to search or ignore */
	char  **fitgrouplist;	/* List of device groups that fit criteria */
	char   *cmdname;	/* Simple command name */
	char   *dgroup;		/* Pointer to device group name in list */
	char   *filename;	/* Pointer to filename in "error" */
	int	exitcode;	/* Value to return to the caller */
	int	sev;		/* Message severity */
	int	optchar;	/* Option character (returned by getopt()) */
	int	andflag;	/* TRUE if anding criteria, FALSE if or'ed */
	int	excludeflag;	/* TRUE if the dgroups list those to exclude */
	int	allflag;	/* TRUE if all device grps are to be displayed */
	int	options;	/* Options to pass to getdgrp() */
	int	usageerr;	/* TRUE if syntax error */


	/* Build the message label from the (simple) command name */
	if (cmdname = strrchr(argv[0], '/')) cmdname++;
	else cmdname = argv[0];
	(void) strlcat(strcpy(lbl, "UX:"), cmdname, sizeof(lbl));

	/* Only write the text-component of messages (this goes away in SVR4.1) */
	(void) putenv("MSGVERB=text");

	/*
	 *  Parse the command line:
	 *	- Options
	 *	- Selection criteria
	 *	- Device groups to include or exclude
	 */

	/*
	 *  Extract options from the command line
	 */

	/* Initializations */
	andflag = FALSE;		/* No -a */
	excludeflag = FALSE;		/* No -e */
	allflag = FALSE;		/* No -l */
	usageerr = FALSE;		/* No errors yet */

	/*
	 *  Loop until all of the command line options have been parced
	 */
	opterr = FALSE;			/* Don't let getopt() write messages */
	while ((optchar = getopt(argc, argv, "ael")) != EOF) switch (optchar) {

	/* -a  List device groups that fit all of the criteria listed */
	case 'a':
	    if (andflag) usageerr = TRUE;
	    else andflag = TRUE;
	    break;

	/* -e  Exclude those device groups mentioned on the command line */
	case 'e':
	    if (excludeflag) usageerr = TRUE;
	    else excludeflag = TRUE;
	    break;

	/* -l  List all device groups (if no criteria is specified) */
	case 'l':
	    if (allflag) usageerr = TRUE;
	    else allflag = TRUE;
	    break;

	/* Default case -- command usage error */
	case '?':
	default:
	    usageerr = TRUE;
	    break;
	}

	/* If there is a usage error, write an appropriate message and exit */
	if (usageerr) {
	    stdmsg(MM_NRECOV, lbl, MM_ERROR, M_USAGE);
	    exit(EX_ERROR);
	}

	/* Open the device file (if there's one to be opened) */
	if (!_opendevtab("r")) {
	    if (filename = _devtabpath()) {
		(void) snprintf(txt, sizeof(txt), M_DEVTAB, filename);
		exitcode = EX_DTAB;
		sev = MM_ERROR;
	    } else {
		(void) sprintf(txt, M_ERROR, errno);
		exitcode = EX_ERROR;
		sev = MM_HALT;
	    }
	    stdmsg(MM_NRECOV, lbl, sev, txt);
	    exit(exitcode);
	}

	/* Open the device file (if there's one to be opened) */
	if (!_opendgrptab("r")) {
	    if (filename = _dgrptabpath()) {
		(void) snprintf(txt, sizeof(txt), M_DGROUP, filename);
		exitcode = EX_DGRP;
		sev = MM_ERROR;
	    } else {
		(void) sprintf(txt, M_ERROR, errno);
		exitcode = EX_ERROR;
		sev = MM_HALT;
	    }
	    stdmsg(MM_NRECOV, lbl, sev, txt);
	    exit(exitcode);
	}

	/* Build the list of criteria and device groups */
	arglist = argv + optind;
	criterialist = buildcriterialist(arglist);
	dgrouplist = builddgrouplist(arglist);
	options = (excludeflag ? DTAB_EXCLUDEFLAG : 0) |
		  (andflag ? DTAB_ANDCRITERIA : 0) |
		  (allflag ? DTAB_LISTALL : 0) ;

	/*
	 *  Get the list of device groups that meets the criteria requested.
	 *  If we got a list (that might be empty), write that list to the
	 *  standard output file (stdout).
	 */

	exitcode = EX_OK;
	if (!(fitgrouplist = getdgrp(dgrouplist, criterialist, options))) {
	    exitcode = EX_ERROR;
	}
	else for (dgroup = *fitgrouplist++ ; dgroup ; dgroup = *fitgrouplist++)
		(void) puts(dgroup);

	/* Finished */
	return(exitcode);
}

/*
 *  char **buildcriterialist(arglist)
 *	char **arglist
 *
 *	This function builds a list of criteria descriptions from the
 *	list of arguments given.  The list returned is in malloc()ed
 *	space.
 *
 *  Arguments:
 *	arglist		The address of the first element in the list
 *			of arguments (possibly) containing criterion
 *
 *  Returns:  char **
 *	A pointer to the first element in the list of criterion.
 *	If there was a problem, the function returns (char **) NULL.
 *	If there are no criteria in the list, the function returns
 *	an empty list.
 */

static char  **
buildcriterialist(arglist)
	char  **arglist;	/* Pointer to the list of argument pointers */
{
	/*
	 *  Automatic data
	 */

	char	      **pp; 		/* Pointer to a criteria */
	void	       *allocbuf;	/* Pointer to the allocated data */
	int		ncriteria;	/* Number of criteria found */


	/*
	 *  Search the argument list, looking for the end of the list or
	 *  the first thing that's not a criteria.  (A criteria is a
	 *  character-string that contains a colon (':') or an equal-sign ('=')
	 */

	pp = arglist;
	ncriteria = 1;
	while (*pp && (strchr(*pp, '=') || strchr(*pp, ':'))) {
	    ncriteria++;
	    pp++;
	}

	/* Allocate space for the list of criteria pointers */
	if (allocbuf = malloc(ncriteria*sizeof(char **))) {

	    /* Build the list of criteria arguments */
	    pp = (char **) allocbuf;
	    while ((*arglist != (char *) NULL) && isacriterion(*arglist)) *pp++ = *arglist++;
	    *pp = (char *) NULL;
	}

	return ((char **) allocbuf);
}

/*
 *  char **builddgrouplist(arglist)
 *	char  **arglist
 *
 *	This function returns a pointer to the first element in a list of
 *	device-groups (i.e. not criteria) specified in the list of arguments
 *	whose first element is pointed to by <arglist>.
 *
 *  Arguments:
 *	arglist		The address of the first element in the list of
 *			arguments to be searched for non-criteria
 *
 *  Returns:  char **
 *	The address of the first item in the list of arguments that are
 *	not criteria.  If none, the function returns a pointer to a
 *	null list.
 *
 *  Note:
 *	- The current implementation returns a pointer to an element in
 *	  <arglist>.
 */

static char  **
builddgrouplist(arglist)
	char  **arglist;	/* First item in the list of arguments */
{
	/*
	 *  Automatic data
	 */

	/*
	 *  Search the argument list, looking for the end of the list or
	 *  the first thing that's not a criteria.  It is the first device
	 *  group in the list of device groups (if any).
	 */

	while (*arglist && isacriterion(*arglist)) arglist++;

	/* Return a pointer to the argument list. */
	return(arglist);
}
/*
 * 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	*/

/*LINTLIBRARY*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <devmgmt.h>

extern char	*optarg;
extern int	optind,
		ckquit,
		ckwidth;

char	*prog;
char	*label, *fsname;
char	*prompt;
int	options = 0;
int	kpid = (-2);
int	signo = SIGKILL;

static void usage(void);

/*
 * Given argv[0], return a pointer to the basename of the program.
 */
static char *
prog_name(char *arg0)
{
	char *str;

	/* first strip trailing '/' characters (exec() allows these!) */
	str = arg0 + strlen(arg0);
	while (str > arg0 && *--str == '/')
		*str = '\0';
	if ((str = strrchr(arg0, '/')) != NULL)
		return (str + 1);
	return (arg0);
}

int
main(int argc, char **argv)
{
	int c, n;

	prog = prog_name(argv[0]);

	while ((c = getopt(argc, argv, "fFownx:l:p:k:s:?QW:")) != EOF) {
		switch (c) {
		case 'Q':
			ckquit = 0;
			break;

		case 'W':
			ckwidth = atol(optarg);
			break;

		case 'f':
			options |= DM_FORMAT;
			break;

		case 'F':
			options |= DM_FORMFS;
			break;

		case 'o':
			options |= DM_OLABEL;
			break;

		case 'n':
			options |= DM_BATCH;
			break;

		case 'w':
			options |= DM_WLABEL;
			break;

		case 'l':
			if (label)
				usage();
			label = optarg;
			break;

		case 'p':
			prompt = optarg;
			break;

		case 'x':
			if (label)
				usage();
			label = optarg;
			options |= DM_ELABEL;
			break;

		case 'k':
			kpid = atol(optarg);
			break;

		case 's':
			signo = atol(optarg);
			break;

		default:
			usage();
		}
	}

	if ((optind+1) != argc)
		usage();

	switch (n = getvol(argv[optind], label, options, prompt)) {
	case 0:
		break;

	case 1:
		(void) fprintf(stderr,
			"%s: ERROR: unable to access device <%s>\n",
			prog, argv[optind]);
		break;

	case 2:
		(void) fprintf(stderr, "%s: ERROR: unknown device <%s>\n",
			prog, argv[optind]);
		break;

	case 3:
		if (kpid > -2)
			(void) kill(kpid, signo);
		break;

	case 4:
		(void) fprintf(stderr, "%s: ERROR: bad label on <%s>\n",
			prog, argv[optind]);
		break;

	default:
		(void) fprintf(stderr, "%s: ERROR: unknown device error\n",
			prog);
		break;
	}

	return (n);
}

static void
usage()
{
	fprintf(stderr,
	    "usage: %s [-owfF] [-x extlabel] [-l [fsname],volname] device\n",
	    prog);
	fprintf(stderr,
	    "usage: %s [-n] [-x extlabel] [-l [fsname],volname] device\n",
	    prog);
	exit(1);
}
/*
 * 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   */

/*
 *  listdgrp.c
 *
 *  Contains
 *	listdgrp	Writes on the standard output stream a list of devices
 *			that belong to the specified device group
 */

#include	<sys/types.h>
#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>
#include	<errno.h>
#include	<devmgmt.h>
#include	<devtab.h>
#include	<fmtmsg.h>


/*
 *  Local Definitions
 *	TRUE		Boolean TRUE value (if not already defined)
 *	FALSE		Boolean not-TRUE value (if not already defined)
 */

#ifndef	TRUE
#define	TRUE		('t')
#endif

#ifndef	FALSE
#define	FALSE		(0)
#endif

/*
 *  Messages:
 *	M_USAGE		Command usage error
 *	M_NODGRP	Device group not found
 *	M_DGRPTAB	Device-group table not found
 *	M_ERROR		Internal error
 */

#define	M_USAGE		"usage: listdgrp dgroup"
#define	M_NODGRP	"Device group not found: %s"
#define	M_DGRPTAB	"Cannot open device-group table: %s"
#define	M_ERROR		"Internal error, errno=%d"


/*
 *  Exit codes
 *	EX_OK		Exiting okay, no problem
 *	EX_ERROR	Some problem with the command
 *	EX_NODGRPTAB	Device group table could not be opened
 *	EX_NODGROUP	Device group couldn't be found
 */

#define	EX_OK		0
#define	EX_ERROR	1
#define	EX_NODGRPTAB	2
#define	EX_NODGROUP	3


/*
 *  Macros
 *	stdmsg(r,l,s,t)	    Write a message in standard format
 *				r	Recoverability flag
 *				l	Label
 *				s	Severity
 *				t	Tag
 */

#define	stdmsg(r,l,s,t)	(void) fmtmsg(MM_PRINT|MM_UTIL|r,l,s,t,MM_NULLACT,MM_NULLTAG)

/*
 *  Global Variables
 */


/*
 *  Static Variables
 *
 *	lbl	Buffer for the message label
 */

static	char	lbl[MM_MXLABELLN+1];
static	char	msg[MM_MXTXTLN+1];

/*
 *  listdgrp <dgroup>
 *
 *	List the devices that belong to the device group <dgroup>.
 *	It writes the list to the standard output file (stdout)
 *	in a new-line list.
 *
 *  Returns:
 *	0	Ok
 *	1	Syntax or other error
 *	2	Device table can't be opened
 *	3	Device group doesn't exist
 */

int
main(int argc, char **argv)
{

	/*
	 *  Automatic data
	 */

	char	      **devices;	/* List of devices in the group */
	char	      **pp;		/* Running pointer to device names */
	char	       *cmdname;	/* Simple command name */
	char	       *dgrptab;	/* The device-group table name */
	char	       *dgroup;		/* Device group to list */
	int		exitcode;	/* Value to return to the caller */
	int		sev;		/* Message severity */
	int		optchar;	/* Option char (from getopt()) */
	int		usageerr;	/* TRUE if syntax error on command */


	/* Build the message label from the (simple) command name */
	if ((cmdname = strrchr(argv[0], '/')) != (char *) NULL) cmdname++;
	else cmdname = argv[0];
	(void) strlcat(strcpy(lbl, "UX:"), cmdname, sizeof(lbl));

	/* Only write the text component of a message (this goes away in SVR4.1) */
	(void) putenv("MSGVERB=text");

	/*
	 *  Parse the command line:
	 *	- Options
	 *	- Device group to display
	 */

	/*
	 *  Extract options from the command line
	 */

	/* Initializations */
	usageerr = FALSE;	/* No errors on the command line (yet) */

	/*
	 *  Loop until all of the command line options have been parced
	 *  (and don't let getopt() write messages)
	 */

	opterr = FALSE;
	while ((optchar = getopt(argc, argv, "")) != EOF) switch (optchar) {

	/* Default case -- command usage error */
	case '?':
	default:
	    usageerr = TRUE;
	    break;
	}

	/* Check the argument count and extract the device group name */
	if (usageerr || (optind != argc-1)) usageerr = TRUE;
	else dgroup = argv[optind];

	/* If there is a usage error, write an appropriate message and exit */
	if (usageerr) {
	    stdmsg(MM_NRECOV, lbl, MM_ERROR, M_USAGE);
	    exit(EX_ERROR);
	}

	/* Open the device-group file (if there's one to be opened) */
	if (!_opendgrptab("r")) {
	    if (dgrptab = _dgrptabpath()) {
		(void) snprintf(msg, sizeof(msg), M_DGRPTAB, dgrptab);
		exitcode = EX_NODGRPTAB;
		sev = MM_ERROR;
	    } else {
		(void) sprintf(msg, M_ERROR, errno);
		exitcode = EX_ERROR;
		sev = MM_HALT;
	    }
	    stdmsg(MM_NRECOV, lbl, sev, msg);
	    exit(exitcode);
	}


	/*
	 * Get the list of devices associated with the device group.
	 * If we get one, write the list to the standard output.
	 * Otherwise, write an appropriate error message
	 */

	exitcode = EX_OK;
	if (devices = listdgrp(dgroup)) {
	    for (pp = devices ; *pp ; pp++) (void) puts(*pp);
	}
	else {
	    if (errno == EINVAL) {
		(void) snprintf(msg, sizeof(msg), M_NODGRP, dgroup);
		stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		exitcode = EX_NODGROUP;
	    }
	    else {
		(void) sprintf(msg, M_ERROR, errno);
		stdmsg(MM_NRECOV, lbl, MM_HALT, msg);
		exitcode = EX_ERROR;
	    }
	}

	/* Finished (now wasn't that special?) */
	return(exitcode);
}
/*
 * 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  	*/

/*
 *	Implements the "putdev" command.
 */
#include	<sys/types.h>
#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>
#include	<errno.h>
#include	<unistd.h>
#include	<fmtmsg.h>
#include	<devmgmt.h>
#include	<devtab.h>


/*
 * General Purpose Constants
 *	TRUE		Boolean TRUE (if not already defined)
 *	FALSE		Boolean FALSE (if not already defined)
 *	NULL		Null address (if not already defined)
 */

#ifndef	TRUE
#define	TRUE	(1)
#endif

#ifndef	FALSE
#define	FALSE	(0)
#endif

/*
 * Exit codes
 *	EX_OK		All went well
 *	EX_ERROR	Usage or internal error
 *	EX_DEVTAB	Had trouble accessing/reading/writing the device table
 *	EX_EXISTS	The specified alias already exists
 *	EX_ATTRIB	One or more attributes requested for removal was not
 *			defined for the device
 *	EX_RELPATH	Pathname supplied for cdevice, bdevice or pathname
 *			attributes was not a full pathname
 */

#define	EX_OK		0
#define	EX_ERROR	1
#define	EX_DEVTAB	2
#define	EX_EXISTS	3
#define	EX_ATTRIB	4
#define	EX_RELPATH	4


/*
 * Error messages
 */

#define	E_USAGE		"usage: putdev -a alias [attribute=value [...]]\n       putdev -m device attribute=value [attribute=value [...]]\n       putdev -d device [attribute [...]]"
#define	E_ALIASIS	"Alias already exists in table: %s"
#define	E_NODEV		"Device does not exist in table: %s"
#define	E_NOALIAS	"Cannot use \"alias\" as an attribute"
#define	E_NOATTR	"Attribute not found: %s"
#define	E_NODEVTAB	"Cannot open the device table: %s"
#define	E_NOMKDTAB	"Cannot create a new device table: %s"
#define	E_INVALIAS	"Not a valid device alias: %s"
#define E_MULTIPLE	"Multiple definitions of an attribute are not allowed."
#define	E_INTERNAL	"Internal error, errno=%d"
#define	E_RELPATH	"Full pathname required for cdevice,bdevice and pathname attributes."


/*
 * Macros
 *	stdmsg(r,l,s,t)	    Using fmtmsg(), write a standard message to the
 *			    standard error stream.
 *			    Where:
 *				r   The recoverability of the error
 *				l   The label-component
 *				s   The severity-component
 *				t   The text-component
 */

#define stdmsg(r,l,s,t) (void) fmtmsg(MM_PRINT|MM_UTIL|r,l,s,t,MM_NULLACT,MM_NULLTAG)


/*
 * Static data
 *	msg		Space for message's text-component
 */

static	char		msg[256];	/* Space for text of message */

/*
 * char *mklbl(cmd)
 *	char   *cmd
 *
 *	This function builds a standard label from the command used to invoke
 *	this process and the standard label prefix ("UX:")
 *
 * Arguments:
 *	char *cmd	The command used to invoke this process.
 *
 * Returns:  char *
 *	Pointer to malloc()ed space containing the standard label,
 *	or (char *) NULL if an error occurred.
 */

static char *
mklbl(cmd)
	char   *cmd;
{
	/* Automatic data */
	char   *rtn;		/* Value to return */
	char   *p;		/* Temporary */

	/* Find the 1st char of the basename of the command */
	if (p = strrchr(cmd, '/')) p++;
	else p = cmd;

	/* Allocate and build the string value to return */
	if (rtn = (char *) malloc(strlen("UX:")+strlen(p)+1)) {
	    (void) strcpy(rtn, "UX:");
	    (void) strcat(rtn, p);
	}


	/* Now that we've done all of that work, change the environment
	 * so that only the text-component is written by fmtmsg().
	 * (This should go away in SVR4.1)
	 */

	(void) putenv("MSGVERB=text");


	/* Done */
	return(rtn);
}

/*
 * putdev -a alias [attribute=value [...]]
 * putdev -m alias attribute=value [attribute=value [...]]
 * putdev -d alias [attribute [...]]
 *
 * 	Modify the device-table.  If -a specified, add a record for <alias>
 * 	to the table.  If -m specified, modify the attributes specified for
 *	the <device> specified.  If -d specified, remove the specified
 *	attributes from the specified device or remove the specified device.
 *
 * Options:
 *	-a		Add an alias description to the device table
 *	-m		Modify an existing device description
 *	-d		(if no attributes specified) remove the specified
 *			device from the device table, or (if attributes
 *			specified) remove the specified attributes from
 *			the specified device.
 *
 * Exit values:
 *	0		All went well
 *	1		Usage error (includes specifying "alias" as an
 *			<attribute>)
 *	2		The device table file could not be opened, read
 *			or modified
 *	3		If -a, the alias already exists.  Otherwise, the
 *			specified device does not exist in the table
 *	4		One of the specified attributes did not exist
 *			for the device and therefore wasn't removed
 */

int
main(int argc, char *argv[])
{
	/* Automatic data */
	char	      **plist;		/* Ptr to list of undef'nd attrs */
	char	       *lbl;		/* Ptr to label for messages */
	char	       *alias;		/* Ptr to <alias> on command-line */
	char	       *device;		/* Ptr to <device> on command-line */
	char	       *p;		/* Temp ptr to char */
	int		noerr;		/* FLAG, TRUE if all's well */
	int		a_seen;		/* TRUE if -a seen on command-line */
	int		m_seen;		/* TRUE if -m seen on command-line */
	int		d_seen;		/* TRUE if -a seen on command-line */
	int		optchar;	/* Option extracted */
	int		exitcd;		/* Value to return at exit */
	int		nattrs;		/* Number of attributes on command */


	/* Generate the label for messages */
	lbl = mklbl(argv[0]);

	/* Extract arguments - validate usage */
	noerr = TRUE;
	a_seen = FALSE;
	m_seen = FALSE;
	d_seen = FALSE;
	opterr = FALSE;
	while ((optchar = getopt(argc, argv, "a:d:m:")) != EOF) switch (optchar) {

	case 'a':
	    if (!(a_seen || m_seen || d_seen)) {
		a_seen = TRUE;
		alias = optarg;
	    }
	    else noerr = FALSE;
	    break;

	case 'd':
	    if (!(a_seen || m_seen || d_seen)) {
		d_seen = TRUE;
		device = optarg;
	    }
	    else noerr = FALSE;
	    break;

	case 'm':
	    if (!(a_seen || m_seen || d_seen)) {
		m_seen = TRUE;
		device = optarg;
	    }
	    else noerr = FALSE;
	    break;

	case '?':
	default:
	    noerr = FALSE;
	}


	/* Write a usage message if we've seen a blatant error */
	if (!(a_seen || m_seen || d_seen) || !noerr) {
	    stdmsg(MM_NRECOV, lbl, MM_ERROR, E_USAGE);
	    exit(EX_ERROR);
	}


	/* Set up */
	exitcd = EX_OK;
	nattrs = argc - optind;


	/*  putdev -a alias [attr=value [...]] */

	if (a_seen) {

	    /* Syntax check */
	    if (nattrs < 0) {
		stdmsg(MM_NRECOV, lbl, MM_ERROR, E_USAGE);
		exitcd = EX_ERROR;
	    } else {

		/* Attempt to add the new alias */
		if (!(_adddevtabrec(alias, &argv[optind]))) {

		    /* Attempt failed.  Write appropriate error message. */

		    switch(errno) {

		    /*
		     * EINVAL indicates that <alias> is not valid or "alias"
		     * was mentioned as <attr> in <attr>=<value> pair.  If the
		     * alias is a valid alias, assume that's the problem.
		     */

		    case EINVAL:
			if (_validalias(alias))
			    p = E_NOALIAS;
			else (void) snprintf(p=msg, sizeof(msg), E_INVALIAS, alias);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, p);
			exitcd = EX_ERROR;
			break;

		    /*
		     * EEXIST indicates that the alias <alias> already exists
		     * in the device table.
		     */

		    case EEXIST:
			(void) snprintf(msg, sizeof(msg), E_ALIASIS, alias);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_EXISTS;
			break;

		    /*
		     * EACCES and ENOENT indicate problems reading or writing
		     * the device table.
		     */

		    case EACCES:
		    case ENOENT:
	                p = _devtabpath();
			if (access(p, R_OK) == 0)
			    (void) snprintf(msg, sizeof(msg), E_NOMKDTAB, p);
			else
			    (void) snprintf(msg, sizeof(msg), E_NODEVTAB, p);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_DEVTAB;
			break;

		    /*
		     * EAGAIN indicates that an attribute was defined on the
		     * command line more than once.
		     */

		    case EAGAIN:
			stdmsg(MM_NRECOV, lbl, MM_ERROR, E_MULTIPLE);
			exitcd = EX_ERROR;
			break;

		    /*
		     * ENXIO indicates that a relative pathname was supplied
		     * for the cdevice, bdevice or pathname attributes.  Full
		     * pathnames are required for these attributes.
		     */
		    case ENXIO:
			stdmsg(MM_NRECOV, lbl, MM_ERROR, E_RELPATH);
			exitcd = EX_RELPATH;
			break;

		    /*
		     * Some other problem (odd?)
		     */

		    default:
			(void) sprintf(msg, E_INTERNAL, errno);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_ERROR;
		    }
		}
	    }
	}   /* End -a case */


	/* putdev -m device attr=value [...] */

	else if (m_seen) {

	    /* Check usage */

	    if (nattrs <= 0) {
		stdmsg(MM_NRECOV, lbl, MM_ERROR, E_USAGE);
		exitcd = EX_ERROR;
	    } else {

		/* Attempt to modify a device's record */
		if (!(_moddevtabrec(device, &argv[optind]))) {

		    /* Modification attempt failed */

		    switch(errno) {

		    /*
		     * EINVAL indicates that "alias" was used as an attribute
		     * in an <attr>=<value> pair.
		     */

		    case EINVAL:
			stdmsg(MM_NRECOV, lbl, MM_ERROR, E_NOALIAS);
			exitcd = EX_ERROR;
			break;

		    /*
		     * ENODEV indicates that the device that was to
		     * be modified doesn't exist.
		     */

		    case ENODEV:
			(void) snprintf(msg, sizeof(msg), E_NODEV, device);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_EXISTS;
			break;

		    /*
		     * ENOENT indicates that the device-table doesn't exist.
		     */

		    case ENOENT:
			(void) snprintf(msg, sizeof(msg), E_NODEVTAB, _devtabpath());
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_DEVTAB;
			break;

		    /*
		     * EACCES indicates that there was a problem reading the
		     * old device table or creating the new table.  If the
		     * old table is readable, assume that we can't create the
		     * new table.  Otherwise, assume that the old table isn't
		     * accessible.
		     */

		    case EACCES:
	                p = _devtabpath();
			if (access(p, R_OK) == 0)
			    (void) snprintf(msg, sizeof(msg), E_NOMKDTAB, p);
			else
			    (void) snprintf(msg, sizeof(msg), E_NODEVTAB, p);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_DEVTAB;
			break;

		    /*
		     * EAGAIN indicates that an attribute was specified more than
		     * once on the command line.
		     */

		    case EAGAIN:
			stdmsg(MM_NRECOV, lbl, MM_ERROR, E_MULTIPLE);
			exitcd = EX_ERROR;
			break;

		    /*
		     * ENXIO indicates that a relative pathname was supplied
		     * for the cdevice, bdevice or pathname attributes.  Full
		     * pathnames are required for these attributes.
		     */
		    case ENXIO:
			stdmsg(MM_NRECOV, lbl, MM_ERROR, E_RELPATH);
			exitcd = EX_RELPATH;
			break;

		    /*
		     * Some strange problem...
		     */

		    default:
			(void) sprintf(msg, E_INTERNAL, errno);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_ERROR;
		    }
		}
	    }
	}   /* End -m case */

	else if (d_seen) {

	    /* putdev -d device [attr [...]] */

	    /* Check usage */
	    if (nattrs < 0) {
		stdmsg(MM_NRECOV, lbl, MM_ERROR, E_USAGE);
		exitcd = EX_ERROR;
	    } else {

		/*
		 * Determine case (removing a device or attributes
		 * to a device.
		 */

		if (nattrs == 0) {

		    /* putdev -d device */

		    /* Attempt to remove the specified device */
		    if (!(_rmdevtabrec(device))) switch(errno) {

			/*
			 * ENODEV indicates that the named device is not
			 * defined in the device table.
			 */

		    case ENODEV:
			(void) snprintf(msg, sizeof(msg), E_NODEV, device);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_EXISTS;
			break;

			/*
			 * ENOENT indicates that the device table can't
			 * be found.
			 */

		    case ENOENT:
			(void) snprintf(msg, sizeof(msg), E_NODEVTAB, _devtabpath());
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_DEVTAB;
			break;

			/*
			 * EACCES indicates that there was a problem reading the
			 * old device table or creating the new table.  If the
			 * old table is readable, assume that we can't create the
			 * new table.  Otherwise, assume that the old table isn't
			 * accessible.
			 */

		    case EACCES:
			p = _devtabpath();
			if (access(p, R_OK) == 0)
			    (void) snprintf(msg, sizeof(msg), E_NOMKDTAB, p);
			else
			    (void) snprintf(msg, sizeof(msg), E_NODEVTAB, p);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_DEVTAB;
			break;

			/*
			 * Some strange problem...
			 */

		    default:
			(void) sprintf(msg, E_INTERNAL, errno);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_ERROR;

		    }   /* End switch */
		}
		else {

		    /* putdev -d device attr [attr [...]] */

		    /*
		     * Attempt to remove the specified attributes from the
		     * specified device.
		     */
		    if (!(_rmdevtabattrs(device, &argv[optind], &plist))) switch(errno) {

			/*
			 * EINVAL indicates that a named attribute was not
			 * defined for the specified device or "alias" was
			 * requested.  If "plist" points to a list of attrs,
			 * the former is the problem.  Otherwise, the latter
			 * is the problem.
			 */

		    case EINVAL:
			if (plist) {
			    exitcd = EX_ATTRIB;
			    for (; *plist; plist++) {
				(void) snprintf(msg, sizeof(msg), E_NOATTR, *plist);
				stdmsg(MM_RECOVER, lbl, MM_WARNING, msg);
			    }
			} else {
			    stdmsg(MM_NRECOV, lbl, MM_ERROR, E_NOALIAS);
			    exitcd = EX_ERROR;
			}
			break;

			/*
			 * ENODEV indicates that the named device is not
			 * defined in the device table.
			 */

		    case ENODEV:
			(void) snprintf(msg, sizeof(msg), E_NODEV, device);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_EXISTS;
			break;

			/*
			 * ENOENT indicates that the device table can't
			 * be found.
			 */

		    case ENOENT:
			(void) snprintf(msg, sizeof(msg), E_NODEVTAB, _devtabpath());
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_DEVTAB;
			break;

			/*
			 * EACCES indicates that there was a problem reading the
			 * old device table or creating the new table.  If the
			 * old table is readable, assume that we can't create the
			 * new table.  Otherwise, assume that the old table isn't
			 * accessible.
			 */

		    case EACCES:
			p = _devtabpath();
			if (access(p, R_OK) == 0)
			    (void) snprintf(msg, sizeof(msg), E_NOMKDTAB, p);
			else
			    (void) snprintf(msg, sizeof(msg), E_NODEVTAB, p);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_DEVTAB;
			break;

			/*
			 * Some strange problem...
			 */

		    default:
			(void) sprintf(msg, E_INTERNAL, errno);
			stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
			exitcd = EX_ERROR;

		    }  /* End switch */

		}   /* End "putdev -d device attr [...]" case */

	    }   /* End passes usage-check case */

	}   /* End -d case */


	/* Done.  Return exit code (determined above) */
	return(exitcd);
}  /* main() */
/*
 * 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  	*/

/*
 *	Implements the "putdgrp" command.
 */
#include	<sys/types.h>
#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>
#include	<errno.h>
#include	<unistd.h>
#include	<fmtmsg.h>
#include	<devmgmt.h>
#include	<devtab.h>


/*
 * General Purpose Constants
 *	TRUE		Boolean TRUE (if not already defined)
 *	FALSE		Boolean FALSE (if not already defined)
 */

#ifndef	TRUE
#define	TRUE	(1)
#endif

#ifndef	FALSE
#define	FALSE	(0)
#endif

/*
 * Exit codes
 *	EX_OK		All went well
 *	EX_ERROR	Usage or internal error
 *	EX_DGROUP	Had trouble accessing/reading/writing the
 *			device-group table
 *	EX_NODGRP	The specified device-group does not exist
 *	EX_NOMEM	One or more device-group members requested for
 *			removal was not defined for the device
 */

#define	EX_OK		0
#define	EX_ERROR	1
#define	EX_DGROUP	2
#define	EX_NODGRP	3
#define	EX_NOMEM	4


/*
 * Error messages
 */

#define	E_USAGE		"usage: putdgrp [-d] dgroup [device [...]]"
#define	E_NODGRP	"Device-group does not exist in table: %s"
#define	E_NOTAMEM	"Device-group member not found: %s"
#define	E_NODGRPTAB	"Cannot open the device-group table: %s"
#define	E_NOMKTAB	"Cannot create a new device-group table: %s"
#define	E_INTERNAL	"Internal error, errno=%d"


/*
 * Macros
 *	stdmsg(r,l,s,t)	    Using fmtmsg(), write a standard message to the
 *			    standard error stream.
 *			    Where:
 *				r   The recoverability of the error
 *				l   The label-component
 *				s   The severity-component
 *				t   The text-component
 */

#define stdmsg(r,l,s,t) (void) fmtmsg(MM_PRINT|MM_UTIL|r,l,s,t,MM_NULLACT,MM_NULLTAG)


/*
 * Static data
 *	msg		Space for message's text-component
 */

static	char		msg[256];	/* Space for text of message */

/*
 * char *mklbl(cmd)
 *	char   *cmd
 *
 *	This function builds a standard label from the command used to invoke
 *	this process and the standard label prefix ("UX:")
 *
 * Arguments:
 *	char *cmd	The command used to invoke this process.
 *
 * Returns:  char *
 *	Pointer to malloc()ed space containing the standard label,
 *	or (char *) NULL if an error occurred.
 */

static char *
mklbl(cmd)
	char   *cmd;
{
	/* Automatic data */
	char   *rtn;		/* Value to return */
	char   *p;		/* Temporary */

	/* Find the 1st char of the basename of the command */
	if (p = strrchr(cmd, '/')) p++;
	else p = cmd;

	/* Allocate and build the string value to return */
	if (rtn = (char *) malloc(strlen("UX:")+strlen(p)+1)) {
	    (void) strcpy(rtn, "UX:");
	    (void) strcat(rtn, p);
	}

	/* Now that we've done all of this work, set up the environemnt
	 * so that only the text-component is written (some requirements
	 * say that standard messages are to be non-standard in SVR4.0,
	 * this is supposed to change in SVR4.1)
	 */

	(void) putenv("MSGVERB=text");

	/* Done */
	return(rtn);
}

/*
 * putdgrp [-d] dgroup [device [...]]
 *
 * Options:
 *	-d
 *
 * Arguments:
 *	dgroup
 *	device
 *
 * Exit values:
 */

int
main(int argc, char *argv[])
{
	/* Automatic data */
	char	      **plist;		/* Ptr to list of nonmembers */
	char	       *lbl;		/* Ptr to label for messages */
	char	       *dgroup;		/* Ptr to <dgroup> on command-line */
	char	       *p;		/* Temp ptr to char */
	int		noerr;		/* FLAG, TRUE if all's well */
	int		d_seen;		/* TRUE if -a seen on command-line */
	int		optchar;	/* Option extracted */
	int		exitcd;		/* Value to return at exit */
	int		nmems;		/* Number of members on the cmd */


	/* Generate the label for messages */
	lbl = mklbl(argv[0]);

	/* Extract arguments - validate usage */
	noerr = TRUE;
	d_seen = FALSE;
	opterr = FALSE;
	while ((optchar = getopt(argc, argv, "d:")) != EOF) switch (optchar) {

	case 'd':
	    if (!d_seen)
	    {
		d_seen = TRUE;
		dgroup = optarg;
	    }
	    else noerr = FALSE;
	    break;

	case '?':
	default:
	    noerr = FALSE;
	}


	/* Write a usage message if we've seen a blatant error */
	if (!noerr || (!d_seen && ((nmems = argc - optind - 1) < 0)) ||
		      (d_seen && ((nmems = argc - optind) < 0))) {
	    stdmsg(MM_NRECOV, lbl, MM_ERROR, E_USAGE);
	    exit(EX_ERROR);
	}


	/* Set up */
	exitcd = EX_OK;


	/* -d on the command line ? */
	if (d_seen) {

	    /*
	     * Determine case (removing a device group or members
	     * of that device group.
	     */

	    if (nmems == 0) {

		/* putdgrp -d dgroup */

		/* Attempt to remove the specified device */
		if (!(_rmdgrptabrec(dgroup))) switch(errno) {

		    /*
		     * EINVAL indicates that the named device-group was
		     * not found in the device-group table.
		     */

		case EINVAL:
		    (void) snprintf(msg, sizeof(msg), E_NODGRP, dgroup);
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		    exitcd = EX_NODGRP;
		    break;

		    /*
		     * ENOENT indicates that the device-group table can't
		     * be found.
		     */

		case ENOENT:
		    (void) snprintf(msg, sizeof(msg), E_NODGRPTAB, _dgrptabpath());
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		    exitcd = EX_DGROUP;
		    break;

		    /*
		     * EACCES indicates that there was a problem reading the
		     * old device-group table or creating the new table.  If the
		     * old table is readable, assume that we can't create the
		     * new table.  Otherwise, assume that the old table isn't
		     * accessible.
		     */

		case EACCES:
		    p = _dgrptabpath();
		    if (access(p, R_OK) == 0)
			(void) snprintf(msg, sizeof(msg), E_NOMKTAB, p);
		    else
			(void) snprintf(msg, sizeof(msg), E_NODGRPTAB, p);
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		    exitcd = EX_DGROUP;
		    break;

		    /*
		     * Some strange problem...
		     */

		default:
		    (void) snprintf(msg, sizeof(msg), E_INTERNAL, errno);
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		    exitcd = EX_ERROR;

		}   /* End switch */
	    }
	    else {

		/* putdgrp -d dgroup device [device [...]] */

		/*
		 * Attempt to remove the specified devices from the
		 * specified device-group.
		 */
		if (!(_rmdgrpmems(dgroup, &argv[optind], &plist))) switch(errno) {

		    /*
		     * ENODEV indicates that a named device was not part
		     * of the specified device group.
		     */

		case ENODEV:
		    exitcd = EX_NOMEM;
		    for (; *plist; plist++) {
			(void) snprintf(msg, sizeof(msg), E_NOTAMEM, *plist);
			stdmsg(MM_RECOVER, lbl, MM_WARNING, msg);
		    }
		    break;

		    /*
		     * EINVAL indicates that the named device-group is not
		     * defined in the device-group table.
		     */

		case EINVAL:
		    (void) snprintf(msg, sizeof(msg), E_NODGRP, dgroup);
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		    exitcd = EX_NODGRP;
		    break;

		    /*
		     * ENOENT indicates that the device table can't
		     * be found.
		     */

		case ENOENT:
		    (void) snprintf(msg, sizeof(msg), E_NODGRPTAB, _dgrptabpath());
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		    exitcd = EX_DGROUP;
		    break;

		    /*
		     * EACCES indicates that there was a problem reading the
		     * old device table or creating the new table.  If the
		     * old table is readable, assume that we can't create the
		     * new table.  Otherwise, assume that the old table isn't
		     * accessible.
		     */

		case EACCES:
		    p = _dgrptabpath();
		    if (access(p, R_OK) == 0)
			(void) snprintf(msg, sizeof(msg), E_NOMKTAB, p);
		    else
			(void) snprintf(msg, sizeof(msg), E_NODGRPTAB, p);
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		    exitcd = EX_DGROUP;
		    break;

		    /*
		     * Some strange problem...
		     */

		default:
		    (void) sprintf(msg, E_INTERNAL, errno);
		    stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		    exitcd = EX_ERROR;

		}  /* End switch */

	    }   /* End "putdgrp -d device attr [...]" case */


	}   /* End -d case */

	else {
	    /* Standard case (no -d on the command) */
	    if (!(_adddgrptabrec(argv[optind], &argv[optind+1]))) switch(errno) {

		/*
		 * ENOENT indicates that the device-group table does not exist.
		 */

	    case ENOENT:
		(void) snprintf(msg, sizeof(msg), E_NODGRPTAB, _dgrptabpath());
		stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		exitcd = EX_DGROUP;
		break;

		/*
		 * EACCES indicates that the device-group table could not be
		 * opened or the new device-group table could not be created.
		 */

	    case EACCES:
		p = _dgrptabpath();
		if (access(p, R_OK) == 0)
			(void) snprintf(msg, sizeof(msg), E_NOMKTAB, p);
		else
			(void) snprintf(msg, sizeof(msg), E_NODGRPTAB, p);
		stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		exitcd = EX_DGROUP;
		break;

		/*
		 * Some strange error (memory?)
		 */

	    default:
		(void) sprintf(msg, E_INTERNAL, errno);
		stdmsg(MM_NRECOV, lbl, MM_ERROR, msg);
		exitcd = EX_ERROR;
	    }
	}

	/* Done.  Return exit code (determined above) */
	return(exitcd);
}  /* main() */