return umGetNextRowData(UM_USER_TABLENAME, UM_NAME, userLast);
}

/******************************************************************************/
/*
 *	umUserExists()	Returns TRUE if userid exists.
 */

bool_t umUserExists(char_t *user)
{
	a_assert(user && *user);

	if (dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0) >= 0) {
		return TRUE;
	} else {
		return FALSE;
	}
}

/******************************************************************************/
/*
 *	umGetUserPassword() returns a de-crypted copy of the user password
 */

char_t *umGetUserPassword(char_t *user)
{
	char_t	*password;
	int		row;

	a_assert(user && *user);

	password = NULL;
	row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0);

	if (row >= 0) {
		char_t *pass = NULL;
		dbReadStr(didUM, UM_USER_TABLENAME, UM_PASS, row, &pass);
/*
 *		Decrypt	password
 *		Note, this function returns a copy of the password, which must
 *		be deleted at some time in the future.
 */
		password = bstrdup(B_L, pass);
		umEncryptString(password);
	}

	return password;
}

/******************************************************************************/
/*
 *	umSetUserPassword() updates the user password in the user "table" after
 *						encrypting the given password
 */

int	umSetUserPassword(char_t *user, char_t *pass)
{
	int		row, nRet;
	char_t	*password;

	a_assert(user && *user);
	a_assert(pass && *pass);
	trace(3, T("UM: Attempting to change the password for user <%s>\n"), user);
/*
 *	Find the row of the user
 */
	if ((row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0)) < 0) {
		return UM_ERR_NOT_FOUND;
	}

	password = bstrdup(B_L, pass);
	umEncryptString(password);
	nRet = dbWriteStr(didUM, UM_USER_TABLENAME, UM_PASS, row, password);
	bfree(B_L, password);

	return nRet;
}

/******************************************************************************/
/*
 *	umGetUserGroup() returns the name of the user group
 */

char_t *umGetUserGroup(char_t *user)
{
	char_t	*group;
	int		row;

	a_assert(user && *user);
	group = NULL;
/*
 *	Find the row of the user
 */
	row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0);

	if (row >= 0) {
		dbReadStr(didUM, UM_USER_TABLENAME, UM_GROUP, row, &group);
	}

	return group;
}

/******************************************************************************/
/*
 *	umSetUserGroup() Sets the name of the user group for the user
 */

int	umSetUserGroup(char_t *user, char_t *group)
{
	int row;

	a_assert(user && *user);
	a_assert(group && *group);
/*
 *	Find the row of the user
 */
	row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0);

	if (row >= 0) {
		return dbWriteStr(didUM, UM_USER_TABLENAME, UM_GROUP, row, group);
	} else {
		return UM_ERR_NOT_FOUND;
	}
}

/******************************************************************************/
/*
 *	umGetUserEnabled() - returns if the user is enabled
 *	Returns FALSE if the user is not found.
 */

bool_t	umGetUserEnabled(char_t *user)
{
	int disabled, row;

	a_assert(user && *user);

	disabled = 1;
/*
 *	Find the row of the user
 */
	row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0);

	if (row >= 0) {
		dbReadInt(didUM, UM_USER_TABLENAME, UM_DISABLE, row, &disabled);
	}

	return (bool_t)!disabled;
}

/******************************************************************************/
/*
 *	umSetUserEnabled() Enables/disables the user
 */
int	umSetUserEnabled(char_t *user, bool_t enabled)
{
	int row;

	a_assert(user && *user);
/*
 *	Find the row of the user
 */
	row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0);
	if (row >= 0) {
		return dbWriteInt(didUM, UM_USER_TABLENAME, UM_DISABLE, row, !enabled);
	} else {
		return UM_ERR_NOT_FOUND;
	}
}

/******************************************************************************/
/*
 *	umGetUserProtected() - determine deletability of user
 */

bool_t umGetUserProtected(char_t *user)
{
	int protect, row;

	a_assert(user && *user);
/*
 *	Find the row of the user
 */
	row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0);
	protect = FALSE;

	if (row >= 0) {
		dbReadInt(didUM, UM_USER_TABLENAME, UM_PROT, row, &protect);
	}

	return (bool_t)protect;
}

/******************************************************************************/
/*
 *	umSetUserProtected() sets the delete protection for the user
 */
int	umSetUserProtected(char_t *user, bool_t protect)
{
	int row;

	a_assert(user && *user);
/*
 *	Find the row of the user
 */
	row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0);

	if (row >= 0) {
		return dbWriteInt(didUM, UM_USER_TABLENAME, UM_PROT, row, protect);
	} else {
		return UM_ERR_NOT_FOUND;
	}
}


/******************************************************************************/
/*
 *	umAddGroup() adds a group to the "Group" table
 */

int	umAddGroup(char_t *group, short priv, accessMeth_t am, 
			   bool_t prot, bool_t disabled)
{
	int row;

	a_assert(group && *group);
	trace(3, T("UM: Adding group <%s>\n"), group);
	
/*
 *	Do not allow duplicates
 */
	if (umGroupExists(group)) {
		return UM_ERR_DUPLICATE;
	}

/*
 *	Only allow valid characters in key field
 */
	if (!umCheckName(group)) {
		return UM_ERR_BAD_NAME;
	}

/*
 *	Add a new row to the table
 */
	if ((row = dbAddRow(didUM, UM_GROUP_TABLENAME)) < 0) {
		return UM_ERR_GENERAL;
	}

/*
 *	Write the key field
 */
	if (dbWriteStr(didUM, UM_GROUP_TABLENAME, UM_NAME, row, group) != 0) {
		return UM_ERR_GENERAL;
	}

/*
 *	Write the remaining fields
 */
	dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_PRIVILEGE, row, priv);
	dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_METHOD, row, (int) am);
	dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_PROT, row, prot);
	dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_DISABLE, row, disabled);

	return 0;
}

/******************************************************************************/
/*
 *	umDeleteGroup() - Delete a user group, if not protected
 */

int	umDeleteGroup(char_t *group)
{
	int row;

	a_assert(group && *group);
	trace(3, T("UM: Deleting Group <%s>\n"), group);

/*
 *	Check to see if the group is in use
 */
	if (umGetGroupInUse(group)) {
		return UM_ERR_IN_USE;
	} 

/*
 *	Check to see if the group is delete-protected
 */
	if (umGetGroupProtected(group)) {
		return UM_ERR_PROTECTED;
	} 

/*
 *	Find the row of the group to delete
 */
	if ((row = dbSearchStr(didUM, UM_GROUP_TABLENAME, UM_NAME, group, 0)) < 0) {
		return UM_ERR_NOT_FOUND;
	}

	return dbDeleteRow(didUM, UM_GROUP_TABLENAME, row);
}

/******************************************************************************/
/*
 *	umGroupExists() returns TRUE if group exists, FALSE otherwise
 */

bool_t umGroupExists(char_t *group)
{
	a_assert(group && *group);

	if (dbSearchStr(didUM, UM_GROUP_TABLENAME, UM_NAME, group, 0) >= 0) {
		return TRUE;
	} else {
		return FALSE;
	}
}


/******************************************************************************/
/*
 *	umGetGroupInUse() returns TRUE if the group is referenced by a user or by
 *  an access limit.
 */

bool_t umGetGroupInUse(char_t *group)
{
	a_assert(group && *group);

/*
 *	First, check the user table
 */
	if (dbSearchStr(didUM, UM_USER_TABLENAME, UM_GROUP, group, 0) >= 0) {
		return TRUE;
	} 

/*
 *	Second, check the access limit table
 */
	if (dbSearchStr(didUM, UM_ACCESS_TABLENAME, UM_GROUP, group, 0) >= 0) {
		return TRUE;
	} 

	return FALSE;
}


/******************************************************************************/
/*
 *	umGetFirstGroup() - return a pointer to the first non-blank group name
 */

char_t *umGetFirstGroup()
{
	return umGetFirstRowData(UM_GROUP_TABLENAME, UM_NAME);
}

/******************************************************************************/
/*
 *	umGetNextGroup() -	return a pointer to the first non-blank group name
 *						following the given group name
 */

char_t *umGetNextGroup(char_t *groupLast)
{
	return umGetNextRowData(UM_GROUP_TABLENAME, UM_NAME, groupLast);
}

/******************************************************************************/
/*
 *	Returns the default access method to use for a given group
 */

accessMeth_t umGetGroupAccessMethod(char_t *group)
{
	int am, row;

	a_assert(group && *group);
	row = dbSearchStr(didUM, UM_GROUP_TABLENAME, UM_NAME, group, 0);

	if (row >= 0) {
		dbReadInt(didUM, UM_GROUP_TABLENAME, UM_METHOD, row, (int *)&am);
	} else {
		am = AM_INVALID;
	}

	return (accessMeth_t) am;
}

/******************************************************************************/
/*
 *	Set the default access method to use for a given group
 */

int	umSetGroupAccessMethod(char_t *group, accessMeth_t am)
{
	int row;

	a_assert(group && *group);
	row = dbSearchStr(didUM, UM_GROUP_TABLENAME, UM_NAME, group, 0);

	if (row >= 0) {
		return dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_METHOD, row, (int) am);
	} else {
		return UM_ERR_NOT_FOUND;
	}
}

/******************************************************************************/
/*
 *	Returns the privilege mask for a given group
 */

short umGetGroupPrivilege(char_t *group)
{
	int privilege, row;

	a_assert(group && *group);
	privilege = -1;
	row = dbSearchStr(didUM, UM_GROUP_TABLENAME, UM_NAME, group, 0);

	if (row >= 0) {
		dbReadInt(didUM, UM_GROUP_TABLENAME, UM_PRIVILEGE, row, &privilege);
	}

	return (short) privilege;
}

/******************************************************************************/
/*
 *	Set the privilege mask for a given group
 */

int	umSetGroupPrivilege(char_t *group, short privilege)
{
	int row;

	a_assert(group && *group);
	row = dbSearchStr(didUM, UM_GROUP_TABLENAME, UM_NAME, group, 0);

	if (row >= 0) {
		return dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_PRIVILEGE, row, 
			(int)privilege);
	} else {
		return UM_ERR_NOT_FOUND;
	}
}

/******************************************************************************/
/*
 *	Returns the enabled setting for a given group.
 *	Returns FALSE if group is not found.
 */

bool_t umGetGroupEnabled(char_t *group)
{
	int disabled, row;

	a_assert(group && *group);
	row = dbSearchStr(didUM, UM_GROUP_TABLENAME, UM_NAME, group, 0);
	disabled = 1;

	if (row >= 0) {
		dbReadInt(didUM, UM_GROUP_TABLENAME, UM_DISABLE, row, &disabled);
	}

	return (bool_t) !disabled;
}

/******************************************************************************/
/*
 *	Sets the enabled setting for a given group.
 */

int umSetGroupEnabled(char_t *group, bool_t enabled)
{
	int row;