/*
 * 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 (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/


/*
 * Copyright (c) 1997, by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*LINTLIBRARY*/

/*
 * Globals defined:
 *
 *	devreserv()	Reserve a set of OA&M devices
 *	devfree()	Free a reserved device
 *	reservdev()	Get a list of reserved devices
 *	_openlkfile()	Opens the lock file
 *	_rsvtabpath()	Get the pathname of the lock table file
 *	_closelkfile()	Closes the lock file
 */

/*
 * Headers referenced:
 *	<sys/types.h>	System data types
 *	<errno.h>	Error definitions (including "errno")
 *	<string.h>	String handling definitions
 *	<fcntl.h>	File control definitions
 *	<unistd.h>	Unix standard value definitions
 *	<devmgmt.h>	Global Device Management definitions
 *	"devtab.h"	Local Device Management definitions
 */

#include	<sys/types.h>
#include	<errno.h>
#include	<string.h>
#include	<fcntl.h>
#include	<unistd.h>
#include	<stdlib.h>
#include	<devmgmt.h>
#include	"devtab.h"

/*
 * Local Definitions:
 */


/*
 * Local data types:
 *	struct devlks	Structure that defines locking information (key
 *			with alias name (may be '\0' terminated)
 */

struct devlks {
	int	lk_key;
	char	lk_alias[((DTAB_MXALIASLN+2)/2)*2];
};


/*
 * Local Functions:
 *	isanullstr()	Is a character string a null string ("")?
 *	getlkcnt()	Get the number of devices locked
 *	locklkfile()	Lock the OA&M Device locking file
 *	getlocks()	Get the device locks from the device-lock file
 *	islocked()	Determines if a device is locked
 *	putlocks()	Close the device locks w/ update
 *	freelkfile()	Close the device locks w/o updating
 *	compresslks()	Compresses the table containing lock info
 */

#define	isanullstr(s)	(s[0] == '\0')

static	int	locklkfile(short);	/* Lock the lock file */
static	int	getlkcnt(void);		/* Get the number of locked devices */
static	int	getlocks(void);		/* Get the lock information */
static	int	putlocks(char **, int); /* Update lock information */
static	int	freelkfile(void);	/* Free lock information (no update) */
static	char   *islocked(char *);	/* Determines if a device is locked */


/*
 * Static data
 */

static	struct flock	lkinfo = {0, 0, 0, 0, 0};
static	struct devlks  *locklist;
static	int		lockcount;
static	int		lkfilefd = -1;

/*
 * char *_rsvtabpath()
 *
 *	Determines the pathname of the device reservation table file
 *
 *	Uses the following sequential steps:
 *	     1)	If OAM_DEVLKFILE is defined and is not null, use that as
 *		the pathname to the file
 *	     2)	Otherwise, use the devault name found in DVLK_PATH (defined
 *		in the header file <devtab.h>
 *
 *  Arguments:  None
 *
 *  Returns:  char *
 *	A pointer to the filename in malloc()ed memory or (char *) NULL if
 *	it fails.  "errno" will indicate the error if it fails.
 */

char *
_rsvtabpath(void)
{
	/* Automatics */
	char		*lockname;	/* Name of the lockfile */
#ifdef	DEBUG
	char		*p;		/* Temporary pointer */
#endif

#ifdef	DEBUG
	p = getenv(OAM_DEVLKTAB);
	if ((p != NULL) && (*p != '\0')) {
	    if (lockname = malloc(strlen(p)+1))
		(void) strcpy(lockname, p);
	} else {
#endif
	    if (lockname = malloc(strlen(DVLK_PATH)+1))
		(void) strcpy(lockname, DVLK_PATH);

#ifdef	DEBUG
	}
#endif

	/* Fini -- return a pointer to the lockfile pathname */
	return (lockname);
}

/*
 *  int _openlkfile()
 *
 *	The _openlkfile() function opens a device-reservation table file
 *	for read/write access.
 *
 *  Arguments: None
 *
 *  Returns:  int
 *	TRUE if successful, FALSE otherwise.
 *
 *  Statics Used:
 *	lkfilefd	Lock file file descriptor
 */

int
_openlkfile(void)
{
	/*
	 *  Automatic data
	 */

	char   *lockname;		/* Name of the lock file */


	/* Close the lockfile -- it might be open */
	(void) _closelkfile();

	/* If we can get the name of the lock file ... */
	if (lockname = _rsvtabpath()) {

	    /* Open it */
	    lkfilefd = open(lockname, O_RDWR|O_CREAT, 0600);
	    free(lockname);

	}

	/*  Finis  */
	return ((lkfilefd != -1) ? TRUE : FALSE);
}

/*
 * int _closelkfile()
 *
 *	Function closes the device-reservation table file and sets the
 *	necessary external variables to indicate such.
 *
 *  Arguments:  None
 *
 *  Returns:  int
 *	Same as close()
 *
 *  Statics referenced:
 *	lkfilefd	The device reservation table file's file descriptor
 */

int
_closelkfile(void)
{
	/* Automatics */
	int	rtnval;		/* Value to return */

	/* Close the lock file if it's open */
	if (lkfilefd != -1) rtnval = close(lkfilefd);
	else rtnval = 0;

	/* Indicate that the lock-file is closed */
	lkfilefd = -1;

	/* Finis */
	return (rtnval);
}

/*
 *  int locklkfile(lkflag)
 *	short		lkflag
 *
 *	This function locks the device lock file.  If the request cannot
 *	be serviced, it keeps on trying until it manages to lock the file
 *	or it encounters an error.
 *
 *  Arguments:
 *	lkflag		Flag (from FCNTL(BA_OS)) indicating which type
 *			of lock is being requested.  Values that make
 *			sense:
 *				F_RDLCK:	Read lock.
 *				F_WRLCK:	Write lock.
 *
 *  Returns: int
 *	TRUE (non-zero) if the function managed to lock the file, FALSE
 *	otherwise ("errno" will indicate the problem).
 *
 *  Statics used:
 *	int lkfilefd		File descriptor of the open lock file
 *	struct flock lkinfo	Structure used by fcntl() to lock a file
 */

static	int
locklkfile(short lkflag)
{
	/* Automatic data */
	int		noerror;	/* TRUE if no error yet */
	int		locked;		/* TRUE if the file is locked */
	int		olderrno;	/* Value of errno on call */


	/* Set up the locking structure */
	lkinfo.l_type = lkflag;

	/* Try to lock the file.  If it's locked, wait and try again */
	noerror = TRUE;
	locked = FALSE;
	olderrno = errno;
	while (noerror && !locked) {
	    if (fcntl(lkfilefd, F_SETLK, &lkinfo) != -1) locked = TRUE;
	    else {
		if ((errno == EACCES) || (errno == EAGAIN)) {
		    errno = olderrno;
		    if (sleep(2)) noerror = FALSE;
		} else noerror = FALSE;
	    }
	}

	/* Return a success flag */
	return (locked);
}

/*
 *  int getlkcnt()
 *
 *	This function extracts the number of currently-locked devices
 *	from the lock file.
 *
 *  Arguments:  None
 *
 *  Returns:  int
 *	The number of devices locked or -1 if an error occurred.
 *
 *  Statics used:
 *	lkfilefd	File descriptor of the open lockfile
 *
 *  Assumptions:
 *    -	The file is positioned to the beginning-of-file
 */

static	int
getlkcnt(void)
{
	/* Automatics */
	int	cntread;		/* Number of bytes read */
	int	lkcnt;			/* Number of current locks */

	/* Get the lock count from the file */
	cntread = (int)read(lkfilefd, &lkcnt, sizeof (int));

	/* If there wasn't one, set to 0.  If error, set to -1 */
	if (cntread != (int)sizeof (int))
		lkcnt = (cntread < 0) ? -1 : 0;

	/* Return the lock count */
	return (lkcnt);
}

/*
 *  int readlocks()
 *
 *	The readlocks() function reads the reserved-device list from
 *	the reserved-device file (which has already been opened)
 *
 *  Arguments:  None
 *
 *  Returns:  int
 *	TRUE if all went well, FALSE otherwise.
 *
 *  Statics Used:
 *	lockcount	Sets this to the number of locks in the lock list
 *	locklist	Sets this to the malloc()ed space containing the
 *			list of reserved devices.
 *	lkfilefd	Reads data from this file
 */

static	int
readlocks(void)
{
	/* Automatics */
	struct devlks  *alloc;		/* Ptr to alloc'ed space */
	int		noerror;	/* TRUE if all is well */
	size_t		bufsiz;		/* # bytes needed for lock data */


	/* Initializations */
	noerror = TRUE;

	/* Get the number of devices currently locked */
	if ((lockcount = getlkcnt()) > 0) {

	    /* Allocate space for the locks */
	    bufsiz = lockcount * sizeof (struct devlks);
	    if (alloc = malloc(bufsiz)) {

		/* Read the locks into the malloc()ed buffer */
		if (read(lkfilefd, alloc, bufsiz) != (ssize_t)bufsiz)
		    noerror = FALSE;

		/* If the read failed, free malloc()ed buffer */
		if (!noerror) free(alloc);

	    } else noerror = FALSE;  /* malloc() failed */

	} else if (lockcount < 0) noerror = FALSE;

	/* Finished */
	if (noerror)
		locklist = (lockcount > 0) ? alloc : NULL;
	return (noerror);
}

/*
 *  int getlocks()
 *
 *	getlocks() extracts the list of locked devices from the file
 *	containing that information.  It returns the number of locked
 *	devices.  If there are any locked devices, it allocates a buffer
 *	for the locked file information, saves that buffer address in
 *	the allocated buffer.  Also, the device lock file is open and
 *	locked if the function is successful.
 *
 *  Arguments:  None
 *
 *  Returns:  int
 *	TRUE if successful, FALSE otherwise.  "errno" will reflect the
 *	error if the function returns FALSE.
 *
 *  Static data referenced:
 *	int lkfilefd			File descriptor of the lock file
 */

static	int
getlocks(void)
{
	/* Automatic data */
	int		noerror;	/* TRUE if all's well */


	/* Initializations */
	noerror = TRUE;

	/* Open the lock file */
	if (_openlkfile()) {

	    /* Lock the lock file */
	    if (locklkfile(F_WRLCK)) {

		/* Get the number of devices currently locked */
		if (!readlocks()) noerror = FALSE;

		/* If something happened, unlock the file */
		if (!noerror) (void) freelkfile();

	    } else noerror = FALSE;  /* Lock failed */

	    /* If something happened, close the lock file */
	    if (!noerror)
		(void) _closelkfile();

	} else noerror = FALSE;				/* Open failed */

	/* Done */
	return (noerror);
}

/*
 *  int writelks(tblcnt)
 *	int	tblcnt
 *
 *	writelks() writes the lock information to the lock file.  Lock
 *	information includes the number of locks (to be) in the table.
 *	Note that functions may still be appending new locks after this
 *	call...
 *
 *  Arguments:
 *	tblcnt	Number of locks in the lock table
 *
 *  Returns:
 *	TRUE if successful, FALSE otherwise with "errno" containing an
 *	indication of the error.
 *
 *  Statics Used:
 *	lockcount	Number of locks to exist
 *	locklist	Table of locks (may not include new ones)
 *	lkfilefd	File descriptor of the lock file
 *
 *  Notes:
 *    - The number of locks that are going to be in the lock file
 *	is in the static variable "lockcount".  <tblcnt> indicates
 *	the number of entries in the lock table.
 */

static	int
writelks(int tblcnt)
{
	/* Automatic data */
	int		noerr;		/* FLAG, TRUE if all's well */
	size_t		tblsz;		/* Size of the table to write */

	/* Initializations */
	noerr = TRUE;

	/* Rewind the OA&M Device Lock File */
	if (lseek(lkfilefd, 0L, 0) >= 0L) {

	    /* Write the number of locks that will (eventually) exist */
	    if (write(lkfilefd, &lockcount, sizeof (int)) == sizeof (int)) {

		/* Write the table as we currently know it */
		tblsz = tblcnt * sizeof (struct devlks);
		if (tblsz) {
		    if (write(lkfilefd, locklist, tblsz) != (ssize_t)tblsz)
			noerr = FALSE;  /* Write of locks failed */
		}
	    } else {
		noerr = FALSE;  /* write() of count failed */
	    }
	} else {
		noerr = FALSE;  /* Rewind failed */
	}

	/* Return an indicator of our success */
	return (noerr);
}

/*
 * int appendlk(key, alias)
 *	int	key
 *	char   *alias
 *
 *	Write device locking information to the device locking file.
 *
 *  Arguments:
 *	key	Key the device is being locked on
 *	alias	The device alias being locked
 *
 *  Returns:  int
 *	TRUE if we successfully appended a lock to the lock file,
 *	FALSE with "errno" set otherwise.
 *
 *  Static data used:
 *	lkfilefd	The open file descriptor for the open device
 *			locking file
 */

static	int
appendlk(
	int key,		/* Lock key */
	char *alias)		/* Alias to lock */
{
	/* Automatic data */
	struct devlks	lk;	/* Structure for writing a lock */

	/* Set up the data to write */
	lk.lk_key = key;
	(void) strcpy(lk.lk_alias, alias);

	/* Write the data, returning an indicator of our success */
	return (write(lkfilefd, &lk,
	    sizeof (struct devlks)) == sizeof (struct devlks));
}

/*
 *  int compresslks()
 *
 *	This function compresses the lock table, squeezing out the empty
 *	lock entries.
 *
 *  Arguments:  none
 *
 *  Returns:  int
 *	The number of non-empty entries in the table.  They will be the
 *	first 'n' entries in the table after compression.
 *
 *  Statics Used
 *	lockcount	Number of locks in the device lock list
 *	locklist	The device lock list
 */

static	int
compresslks(void)
{
	/* Automatics */
	struct devlks  *avail;		/* Pointer to empty slot */
	struct devlks  *p;		/* Running pointer to locks */
	int		nlocks;		/* Number of locks (up to date) */
	int		i;		/* Temporary counter */

	/* Initializations */
	p = locklist;
	nlocks = lockcount;
	avail = NULL;

	/* Loop through the lock list squeezing out unused slots */
	for (i = 0; i < lockcount; i++) {

	    /* If we've found an empty slot ... */
	    if (isanullstr(p->lk_alias)) {

		/*
		 * If we've an empty slot to move to, just decrement
		 * count of used slots.  Otherwise, make it the next
		 * available slot
		 */

		nlocks--;
		if (!avail) avail = p;
	    }

	    else if (avail) {

		/*
		 * If we found a slot in use and there's an
		 * available slot, move this one there
		 */

		(void) strcpy(avail->lk_alias, p->lk_alias);
		avail->lk_key = p->lk_key;
		avail++;
	    }

	    /* Next, please */
	    p++;
	}

	return (nlocks);
}

/*
 *  int freelkfile()
 *
 *	This function unlocks the OA&M device locking file.
 *
 *  Arguments:  None
 *
 *  Returns:  int
 *	TRUE if it successfully unlocked the file, FALSE otherwise
 *	with "errno" set to indicate the problem.
 *
 *  Statics Used:
 *	lkinfo		File-locking structure
 *	lkfilefd	File-descriptor of the open lock file
 */

static	int
freelkfile(void)
{
	/* Automatic data */
	int		noerr;		/* TRUE if all's well */

	/* Set the action to "unlock" */
	lkinfo.l_type = F_UNLCK;

	/* Unlock the file */
	noerr = (fcntl(lkfilefd, F_SETLK, &lkinfo) != -1);

	/* Return an indication of our success */
	return (noerr);
}

/*
 * int putlocks(newlist, key)
 *	char  **newlist
 *	int	key
 *
 *	This function updates the file containing OA&M device locks.
 *
 *  Arguments:
 *	newlist		The address of the list of addresses of device
 *			aliases to add to the list of locked devices
 *	key		The key on which to lock the devices
 *
 *  Returns:  int
 *	TRUE if all went well, FALSE otherwise with "errno" set to an
 *	error code that indicates the problem.
 *
 *  Statics Used:
 *	lockcount	Number of locks in the locked device structure
 *	locklist	Locked device structure
 */

static	int
putlocks(
	char **newlist,	/* New devices to lock */
	int key)	/* Key we're locking stuff on */
{
	/* Automatic data */
	struct devlks  *plk;		/* Ptr into the locks list */
	char		**pp;		/* Pointer into the device list */
	char		**qq;		/* Another ptr into the dev list */
	int		lkndx;		/* Index into locks list */
	int		noerr;		/* TRUE if all's well */
	int		lksintbl;	/* Number of locks in the table */


	/*
	 * Look through the existing lock list, looking for holes we can
	 * use for the newly locked devices
	 */

	plk = locklist;
	pp = newlist;
	lkndx = 0;
	while (*pp && (lkndx < lockcount)) {
	    if (isanullstr(plk->lk_alias)) {
		plk->lk_key = key;
		(void) strcpy(plk->lk_alias, *pp++);
	    }
	    lkndx++;
	    plk++;
	}

	/*
	 * Update the locks file (algorithm depends on whether we're adding
	 * new locks or not.  May be replacing old locks!)
	 */

	if (*pp) {

	/*
	 * Need to expand the locks file
	 *  - Remember the old lock count (in existing lock buffer)
	 *  - Count the number of new locks we need to add
	 *  - Write out the old locks structure
	 *  - Append locks for the newly added locks
	 */

	    lksintbl = lockcount;
	    for (qq = pp; *qq; qq++) lockcount++;
	    noerr = writelks(lksintbl);
	    while (noerr && *pp) noerr = appendlk(key, *pp++);
	} else {

	/*
	 * Don't need to expand the locks file.  Compress the locks
	 * then write out the locks information
	 */

	    lockcount = compresslks();
	    noerr = writelks(lockcount);
	}

	/* Done.  Return an indication of our success */
	return (noerr);
}

/*
 * char *islocked(device)
 *	char	       *device
 *
 *	This function checks a device to see if it is locked.  If it is
 *	not locked, it returns the device alias.
 *
 *	A device is not locked if the device's alias does not appear in
 *	the device locks table, or the key on which the device was locked
 *	is no longer active.
 *
 *  Argumetns:
 *	char *device		The device to be reserved.  This can be
 *				a pathname to the device or a device
 *				alias.
 *
 *  Returns:  char *
 *	Returns a pointer to the device alias if it's not locked, or
 *	(char *) NULL if it's locked or some error occurred.
 *
 *  Static data used:
 *	struct devlks *locklist		Pointer to the list of device locks
 *	int lockcount			The number of devices that are locked
 */

static	char *
islocked(char *device)
{
	/* Automatic data */
	char		*alias;		/* Alias of "device" */
	struct devlks	*plk;		/* Ptr to locking info */
	int		locked;		/* TRUE if device in locked list */
	int		i;		/* Temp counter */

	/* Get the device's alias */
	if (alias = devattr(device, DTAB_ALIAS)) {

	/*
	 * Look through the device locks to see if this device alias
	 * is locked
	 */

	    locked = FALSE;
	    plk = locklist;
	    for (i = 0; !locked && (i < lockcount); i++) {
		if (strncmp(alias, plk->lk_alias, DTAB_MXALIASLN) == 0)
		    locked = TRUE;
		else plk++;
	    }

	    if (locked) {
		    free(alias);
		    alias = NULL;
		    errno = EAGAIN;
	    }

	}  /* devattr() failed, no such device? */

	/* Return pointer to the device */
	return (alias);
}

/*
 *  int unreserv(key, device)
 *	int	key
 *	char   *device
 *
 *	This function removes a device reservation.
 *
 *  Arguments:
 *	int key	The key on which the device was allocated
 *	char *device	The device to be freed.
 *
 *  Returns:  int
 *	TRUE if successful, FALSE otherwise with "errno" set.
 *
 *  Explicit "errno" settings:
 *	(This follows the "signal()" model which gives one the ability
 *	to determine if a device is allocated without having the
 *	permission to free it.)
 *
 *	EINVAL	The device specified was not locked
 *	EPERM	The device specified was locked but not on the
 *		specified key
 *
 *  Static data used:
 *	locklist	List of locked devices
 *	lockcount	Number of entries in the locked-device list
 */

int
unreserv(int key, char *device)
{
	/* Automatics */
	char		*srchalias;	/* Device alias to search table with */
	char		*alias;		/* Device's alias (from devattr()) */
	struct devlks	*plk;		/* Pointer to a device lock */
	int		locked;		/* TRUE if device currently locked */
	int		noerr;		/* TRUE if all's well */
	int		olderrno;	/* Entry value of "errno" */
	int		i;		/* Counter of locks */


	/* Initializations */
	noerr = TRUE;

	/*
	 * Get the device alias.  If none can be found, try to free
	 * whatever it is that was given to us (the possibility exists
	 * that the device has been removed from the device table since
	 * it was reserved, so the device not being in the table shouldn't
	 * pose too much of a problem with us...)
	 */

	olderrno = errno;
	if (alias = devattr(device, DTAB_ALIAS)) srchalias = alias;
	else {
	    errno = olderrno;
	    srchalias = device;
	}

	/* Loop through the locked-device list looking for what we've got... */
	locked = FALSE;
	plk = locklist;
	for (i = 0; !locked && (i < lockcount); i++) {
	    if (strcmp(srchalias, plk->lk_alias) == 0)
		locked = TRUE;
	    else plk++;
	}

	/* Free the alias string (if any), we don't need it anymore */
	if (alias) free(alias);

	/* If the device is locked ... */
	if (locked) {

	/*
	 * If it's locked on the key we've been given, free it.
	 * Otherwise, don't free it and set errno to EPERM
	 */

	    if (plk->lk_key == key) {
		plk->lk_alias[0] = '\0';
	    } else {
		noerr = FALSE;
		errno = EPERM;
	    }
	} else {

	    /* The device isn't locked.  Set errno to EINVAL */
	    noerr = FALSE;
	    errno = EINVAL;
	}

	/* Finished.  Return an indication of our success */
	return (noerr);
}

/*
 *  char **devreserv(key, rsvlst)
 *	int		key
 *	char	      **rsvlist[]
 *
 *	The devreserv() function reserves devices known to the OA&M Device
 *	Management family of functions.  Once a device is reserved, it can't
 *	be reserved by another until it is freed or the process with the
 *	"key" is no longer active.  It returns a list aliases of the devices
 *	it allocated.
 *
 *	The function attempts to reserve a single device from each of the
 *	lists.  It scans each list sequentially until it was able to
 *	reserve a requested device.  If it successfully reserved a device
 *	from each of the lists, it updates the device-locked file and
 *	returns those aliases to the caller.  If it fails, it allocates
 *	nothing and returns (char **) NULL to the caller.  "errno"
 *	indicates the error.
 *
 *  Arguments:
 *	int key			The key on which this device is being reserved.
 *
 *	char **rsvlist[]	The address of the list of addresses of lists
 *				of pointers to the devices to allocate.
 *
 *  Returns:  char **
 *	A pointer to malloc()ed space containing pointers to the aliases
 *	of the reserved devices.  The aliases are in malloc()ed space also.
 *	The list is terminated by the value (char *) NULL.
 *
 *  Static Data Used:
 *	None directly, but functions called share hidden information
 *	that really isn't of concern to devreserv().
 */

char **
devreserv(
	int		key,		/* Key to reserve device on */
	char		**rsvlst[])	/* List of lists of devs to reserve */
{
	char		***ppp;		/* Ptr to current list in rsvlist */
	char		**pp;		/* Ptr to current item in list */
	char		**qq;		/* Ptr to item in rtnlist */
	char		**rr;		/* Ptr to item in aliases */
	char		**aliases;	/* List of aliases allocated */
	char		**rtnlist;	/* Ptr to buf to return */
	char		*alias;		/* Alias of dev to reserve */
	int		noerr;		/* TRUE if all's well */
	int		olderrno;	/* Old value of errno */
	int		gotone;		/* TRUE if unreserved dev found */
	int		foundone;	/* Found a valid device in the list */
	int		ndevs;		/* # of devs to reserve */

	noerr = TRUE;
	ppp = rsvlst;
	olderrno = errno;
	for (ndevs = 0; *ppp++; ndevs++)
		;
	if (rtnlist = malloc((ndevs+1)*sizeof (char **))) {
	    if (aliases = malloc((ndevs+1)*sizeof (char **))) {
		if (getlocks()) {
		    qq = rtnlist;
		    rr = aliases;

		    /* Go through the lists of devices we're to reserve */

		    for (ppp = rsvlst; noerr && *ppp; ppp++) {

			/* Try to reserve a device from each list */
			gotone = FALSE;
			foundone = FALSE;
			for (pp = *ppp; noerr && !gotone && *pp; pp++) {

			/*
			 * Check the next device in the list.  If islocked()
			 * returns that device's alias, it's ours to have
			 */

			    if (alias = islocked(*pp)) {
				gotone = TRUE;
				foundone = TRUE;
				if (*qq = malloc(strlen(*pp)+1)) {
				    (void) strcpy(*qq++, *pp);
				    *rr++ = alias;
				} else {
				    *rr = NULL;
				    noerr = FALSE;
				}
			    } else {
				if (errno == EAGAIN) {
				    foundone = TRUE;
				    errno = olderrno;
				} else if (errno == ENODEV) errno = olderrno;
				else {
				    noerr = FALSE;
				    *rr = NULL;
				}
			    }
			}

			/*
			 * If no device from the list could be reserved,
			 * we've failed
			 */

			if (noerr && !gotone) {
			    noerr = FALSE;
			    if (!foundone) errno = ENODEV;
			    else errno = EAGAIN;
			    *qq = NULL;
			    *rr = NULL;
			}

		    } /* End of loop through lists loop */

		/*
		 * If all went well, update lock file.
		 * Then, free locks
		 */

		    if (noerr) {
			*qq = NULL;
			*rr = NULL;
			if (!putlocks(aliases, key)) noerr = FALSE;
		    }

		    /* Free resources */
		    if (!freelkfile()) noerr = FALSE;
		    if (_closelkfile() != 0) noerr = FALSE;
		    for (qq = aliases; *qq; qq++) free(*qq);
		    if (!noerr)
			for (pp = rtnlist; *pp; pp++)
				free(*pp);

		} else noerr = FALSE; /* Error getting locks */

		free(aliases);

	    } else noerr = FALSE;  /* Malloc() for alias list failed */

	    if (!noerr) {
		free(rtnlist);
		rtnlist = NULL;
	    }

	} else noerr = FALSE;  /* malloc() failed */

	/* Return list or an indication of an error */
	return (noerr ? rtnlist : NULL);
}

/*
 *  int devfree(key, device)
 *	int	key
 *	char   *device
 *
 *	This function unreserves (frees) the given device.  It returns
 *	an indication of success with "errno" containing information about
 *	a failure.
 *
 *  Arguments:
 *	int	key	The key that the device is locked on
 *	char   *device	The device (alias, pathname to, etc.) to be freed.
 *
 *  Returns:  int
 *	0 if successful, -1 with "errno" set if fails.
 */

int
devfree(
	int	key,			/* Key device is locked on */
	char   *device)			/* Device to free */
{
	/* Automatics */
	int	noerr;

	/* Initializations */
	noerr = TRUE;

	/* Get the locks, locking the lock file */
	if (getlocks()) {

	    /* Attempt to unreserve the device */
	    if (unreserv(key, device)) {

		/*
		 * Successful.  Compress the lock structure and
		 * write the new locks
		 */

		lockcount = compresslks();
		if (!writelks(lockcount)) noerr = FALSE;

	    } else noerr = FALSE;  /* Couldn't unreserve the device */

	    /* Unlock and close the locks file */
	    if (!freelkfile()) noerr = FALSE;
	    if (_closelkfile() != 0) noerr = FALSE;

	} else noerr = FALSE;

	/* Return 0 if successful, something else otherwise */
	return (noerr? 0 : -1);
}

/*
 *  struct reservdev **reservdev()
 *
 *	This function returns the list of reserved devices
 *	along with the key on which those devices were locked.
 *
 *  Arguments:  None.
 *
 *  Returns:  struct reservdev **
 *	Pointer to the list of pointers to structures describing
 *	the reserved devices, or (struct reservdev **) NULL if an
 *	error occurred.  The list of pointers is terminated by
 *	(struct reservdev *) NULL.
 *
 *  Statics Used:
 *	locklist	List of reserved devices
 *	lockcount	Number of items in the reserved-devices list
 */

struct reservdev **
reservdev(void)
{
	/* Automatics */
	struct reservdev	**rtnlist;	/* Ptr to return list */
	struct devlks		*p;		/* Running ptr, locklist */
	struct reservdev	**q;		/* Running ptr, rtnlist */
	char			*r;		/* Temp ptr to char */
	size_t			bufsiz;		/* Size of buffer to alloc */
	int			noerr;		/* TRUE if all's well */
	int			i;		/* Lock counter */


	/* Initializations */
	noerr = TRUE;

	/* Open the lock file ... */
	if (_openlkfile()) {

	    /* Put a read-lock on the lock-file ... */
	    if (locklkfile(F_RDLCK)) {

		/* Read the locks ... */
		if (readlocks()) {

		    /* Alloc space for the return list */
		    bufsiz = (lockcount+1) * sizeof (struct reservdev *);
		    if (rtnlist = malloc(bufsiz)) {

			/* Build the return list from the lock list */
			p = locklist;
			q = rtnlist;
			for (i = 0; noerr && (i < lockcount); i++) {
			    if (*q = malloc(sizeof (struct reservdev))) {
				if (r = malloc(strlen(p->lk_alias)+1)) {
				    (*q)->devname = strcpy(r, p->lk_alias);
				    (*q)->key = p->lk_key;
				} else noerr = FALSE;  /* malloc() error */
			    } else noerr = FALSE;  /* malloc() error */
			    p++;
			    q++;
			}

			/*
			 * If no error, terminate the list.  Otherwise, free
			 * the space we've allocated
			 */

			if (noerr) *q = NULL;
			else {
			    for (q = rtnlist; *q; q++) {
				free((*q)->devname);
				free(*q);
			    }
			    free(rtnlist);
			}

		    } else noerr = FALSE;  /* Couldn't malloc() list space */

		} else noerr = FALSE;  /* Problem reading locks */

		/* Free the lock file */
		(void) freelkfile();

	    } else noerr = FALSE;  /* Error locking the lock file */

	    /* Close the lock file */
	    (void) _closelkfile();

	} else noerr = FALSE;  /* Error opening the lock file */

	/* Return ptr to list of locks or NULL if an error has occurred */
	return (noerr ? rtnlist : NULL);
}