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


/*
 * Module:	pkgstr.c
 * Synopsis:	general string services
 * Taxonomy:	project private
 * Debug Flag:	str
 * Description:
 *
 *   This module implements general string utility services
 *
 * Public Methods:
 *
 *   pkgstrAddToken - Add a token to a string
 *   pkgstrContainsToken - Determine if a string contains a specified token
 *   pkgstrConvertPathToBasename - Return copy of base name in path string
 *   pkgstrConvertPathToDirname - Return copy of directory name in path string
 *   pkgstrConvertUllToTimeString_r - convert unsigned long long to time string
 *   pkgstrExpandTokens - Expand tokens from string appending tokens to another
 *   pkgstrGetToken - Get a token from a string
 *   pkgstrGetToken_r - Get a token from a string into a fixed buffer
 *   pkgstrLocatePathBasename - Locate position of base name in path string
 *   pkgstrNumTokens - Determine number of tokens in string
 *   pkgstrPrintf - Create a string from a printf style format and arguments
 *   pkgstrPrintf_r - Create a string from a printf style format and arguments
 *			into a fixed buffer
 *   pkgstrRemoveToken - Remove a token from a string
 *   pkgstrRemoveLeadingWhitespace - remove leading whitespace from string
 *   pkgstrScaleNumericString - Convert unsigned long long to human
 *	readable form
 */

/*
 * Unix Includes
 */

#define	__EXTENSIONS__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libintl.h>
#include <limits.h>
#include <sys/types.h>
#include <assert.h>
#include <errno.h>
#include <libintl.h>
#include <ctype.h>
#include <unistd.h>
#include <strings.h>
#include <stdarg.h>

/*
 * pkglib Includes
 */

#include "pkglib.h"
#include "pkgstrct.h"
#include "libintl.h"
#include "pkglocale.h"

/*
 * External definitions
 */

/*
 * Public methods
 */

/*
 * Name:	pkgstrRemoveLeadingWhitespace
 * Synopsis:	Remove leading whitespace from string
 * Description:	Remove all leading whitespace characters from a string
 * Arguments:	a_str - [RO, *RW] - (char **)
 *			Pointer to handle to string (in allocated storage) to
 *			remove all leading whitespace from
 * Returns:	void
 *			The input string is modified as follows:
 *			== (char *)NULL:
 *				- input string was (char *)NULL
 *				- input string is all whitespace
 *			!= (char *)NULL:
 *				- copy of input string with leading
 *				  whitespace removed
 * CAUTION:	The input string must be allocated space (via mem* or
 *		pkgstr* methods) - it must not be a static or inline
 *		character string
 * NOTE:	The input string a_str will be freed with 'free'
 *		if it is all whitespace, or if it contains any leading
 *		whitespace characters
 * NOTE:    	Any string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the string is no longer needed.
 * Errors:	If the string cannot be created, the process exits
 */

void
pkgstrRemoveLeadingWhitespace(char **a_str)
{
	char	*o_str;

	/* entry assertions */

	assert(a_str != (char **)NULL);

	/* if string is null, just return */

	if (*a_str == (char *)NULL) {
		return;
	}
	o_str = *a_str;

	/* if string is empty, deallocate and return NULL */

	if (*o_str == '\0') {
		/* free string - handle is reset to NULL by free */
		free(*a_str);
		*a_str = (char *)NULL;
		return;
	}

	/* if first character is not a space, just return */

	if (!isspace(*o_str)) {
		return;
	}

	/* advance past all space characters */

	while ((*o_str != '\0') && (isspace(*o_str))) {
		o_str++;
	}

	/* if string was all space characters, deallocate and return NULL */

	if (*o_str == '\0') {
		/* free string - *a_str is reset to NULL by free */
		free(*a_str);
		*a_str = (char *)NULL;
		return;
	}

	/* have non-space/null byte, return dup, deallocate original */

	o_str = strdup(o_str);
	assert(o_str != (char *)NULL);
	if (o_str != (char *)NULL) {
		free(*a_str);
		*a_str = o_str;
	}
}

unsigned long
pkgstrNumTokens(char *a_string, char *a_separators)
{
	int	index;

	if (a_string == (char *)NULL) {
		return (0);
	}

	if (*a_string == '\0') {
		return (0);
	}

	for (index = 0 ; ; index ++) {
		char *p;

		p = pkgstrGetToken((char *)NULL, a_string, index, a_separators);
		if (p == (char *)NULL) {
			return (index);
		}
		free(p);
	}
}

/*
 * Name:	pkgstrPrintf_r
 * Synopsis:	Create string from printf style format and arguments
 * Description:	Call to convert a printf style format and arguments into a
 *		string of characters placed in allocated storage
 * Arguments:	a_buf - [RO, *RW] - (char *)
 *			- Pointer to buffer used as storage space for the
 *			  returned string created
 *		a_bufLen - [RO, *RO] - (int)
 *			- Size of 'a_buf' in bytes - a maximum of 'a_bufLen-1'
 *			  bytes will be placed in 'a_buf' - the returned
 *			  string is always null terminated
 *		a_format - [RO, RO*] (char *)
 *			printf-style format for string to be formatted
 *		VARG_LIST - [RO] (?)
 *			arguments as appropriate to 'format' specified
 * Returns:	void
 */

/*PRINTFLIKE3*/
void
pkgstrPrintf_r(char *a_buf, int a_bufLen, char *a_format, ...)
{
	va_list		ap;
	size_t		vres = 0;

	/* entry assertions */

	assert(a_format != (char *)NULL);
	assert(*a_format != '\0');
	assert(a_buf != (char *)NULL);
	assert(a_bufLen > 1);

	/* generate the results of the printf conversion */

	va_start(ap, a_format);
	vres = vsnprintf(a_buf, a_bufLen-1, a_format, ap);
	va_end(ap);

	assert(vres > 0);
	assert(vres < a_bufLen);

	a_buf[a_bufLen-1] = '\0';
}

/*
 * Name:	pkgstrPrintf
 * Synopsis:	Create string from printf style format and arguments
 * Description:	Call to convert a printf style format and arguments into a
 *		string of characters placed in allocated storage
 * Arguments:	format - [RO, RO*] (char *)
 *			printf-style format for string to be formatted
 *		VARG_LIST - [RO] (?)
 *			arguments as appropriate to 'format' specified
 * Returns:	char *
 *			A string representing the printf conversion results
 * NOTE:    	Any string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the string is no longer needed.
 * Errors:	If the string cannot be created, the process exits
 */

/*PRINTFLIKE1*/
char *
pkgstrPrintf(char *a_format, ...)
{
	va_list		ap;
	size_t		vres = 0;
	char		bfr[1];
	char		*rstr = (char *)NULL;

	/* entry assertions */

	assert(a_format != (char *)NULL);
	assert(*a_format != '\0');

	/* determine size of the message in bytes */

	va_start(ap, a_format);
	vres = vsnprintf(bfr, 1, a_format, ap);
	va_end(ap);

	assert(vres > 0);
	assert(vres < LINE_MAX);

	/* allocate storage to hold the message */

	rstr = (char *)calloc(1, vres+2);
	assert(rstr != (char *)NULL);
	if (rstr == (char *)NULL) {
		return ((char *)NULL);
	}

	/* generate the results of the printf conversion */

	va_start(ap, a_format);
	vres = vsnprintf(rstr, vres+1, a_format, ap);
	va_end(ap);

	assert(vres > 0);
	assert(vres < LINE_MAX);
	assert(*rstr != '\0');

	/* return the results */

	return (rstr);
}

/*
 * Name:	pkgstrExpandTokens
 * Synopsis:	Expand tokens from string appending tokens to another
 * Description:	Given a string and a list of one or more separators,
 *		expand each token from the string and append those tokens
 *		to a string that is in allocated space - create new string
 *		if no string to append to exists.
 * Arguments:	a_old - [RO, *RW] - (char **)
 *			- Pointer to handle to string to append token to
 *			  == (char *)NULL - new string is created
 *		a_separator - [RO, *RO] - (char *)
 *			- separator to end tokens returned
 *		a_separators - [RO, *RO] - (char *)
 *			- String containing one or more characters that
 *			  can separate one "token" from a_string from another
 * Returns:	void
 * NOTE:    	Any token string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the token string is no longer needed.
 */

void
pkgstrExpandTokens(char **a_old, char *a_string, char a_separator,
	char *a_separators)
{
	int		i;
	char		sep[2] = {'\0', '\0'};

	/* convert single separator character into character string */

	sep[0] = a_separator;

	/*
	 * iterate extracting tokens from the source string and adding
	 * those tokens to the target string when the tokens are not
	 * already present in the target string
	 */

	for (i = 0; ; i++) {
		char	*p;

		/* extract the next matching token from the source string */

		p = pkgstrGetToken((char *)NULL, a_string, i, a_separators);

		/* return if no token is available */

		if (p == (char *)NULL) {
			return;
		}

		/*
		 * obtained token from source string: if the token is not
		 * in the target string, add the token to the target string
		 */

		if (pkgstrContainsToken(*a_old, p, sep) == B_FALSE) {
			pkgstrAddToken(a_old, p, *sep);
		}

		/* free up temporary storage used by token from source string */

		free(p);
	}
	/*NOTREACHED*/
}


/*
 * Name:	pkgstrGetToken
 * Synopsis:	Get a separator delimited token from a string
 * Description:	Given a string and a list of one or more separators,
 *		return the position specified token (sequence of one or
 *		more characters that do not include any of the separators)
 * Arguments:	r_sep - [*RW] - (char *)
 *			- separator that ended the token returned
 *			- NOTE: this is a pointer to a "char", e.g.:
 *				- char a;
 *				- pkgstrGetToken(&a, ...)
 *		a_string - [RO, *RO] - (char *)
 *			- pointer to string to extract token from
 *		a_index - [RO, *RO] - (int)
 *			- Index of token to return; '0' is first matching
 *			  token, '1' is second matching token, etc.
 *		a_separators - [RO, *RO] - (char *)
 *			- String containing one or more characters that
 *			  can separate one "token" from another
 * Returns:	char *
 *			== (char *)NULL - no token matching criteria found
 *			!= (char *)NULL - token matching criteria
 * NOTE:    	Any token string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the token string is no longer needed.
 */

char *
pkgstrGetToken(char *r_sep, char *a_string, int a_index, char *a_separators)
{
	char	*p;
	char	*q;
	char	*lasts;

	/* entry assertions */

	assert(a_string != (char *)NULL);
	assert(a_index >= 0);
	assert(a_separators != (char *)NULL);
	assert(*a_separators != '\0');

	/* if returned separator requested, reset to null until token found */

	if (r_sep != (char *)NULL) {
		*r_sep = '\0';
	}

	/* duplicate original string before breaking down into tokens */

	p = strdup(a_string);
	assert(p != (char *)NULL);
	if (p == (char *)NULL) {
		return ((char *)NULL);
	}
	lasts = p;

	/* scan for separators and return 'index'th token found */

	while (q = strtok_r((char *)NULL, a_separators, &lasts)) {
		/* retrieve separator if requested */

		if (r_sep != (char *)NULL) {
			char	*x;

			x = strpbrk(a_string, a_separators);
			if (x) {
				*r_sep = *x;
			}
		}

		/* if this is the 'index'th token requested return it */

		if (a_index-- == 0) {
			char	*tmp;

			/* duplicate token into its own storage */

			tmp = strdup(q);
			assert(tmp != (char *)NULL);
			if (tmp == (char *)NULL) {
				return ((char *)NULL);
			}

			/* free up copy of original input string */

			free(p);

			/* return token found */

			return (tmp);
		}
	}

	/*
	 * token not found
	 */

	/* free up copy of original input string */

	free(p);

	/* return NULL pointer (token not found) */

	return ((char *)NULL);
}

/*
 * Name:	pkgstrGetToken
 * Synopsis:	Get separator delimited token from a string into a fixed buffer
 * Description:	Given a string and a list of one or more separators,
 *		return the position specified token (sequence of one or
 *		more characters that do not include any of the separators)
 *		into a specified buffer of a fixed maximum size
 * Arguments:	r_sep - [*RW] - (char *)
 *			- separator that ended the token returned
 *			- NOTE: this is a pointer to a "char", e.g.:
 *				- char a;
 *				- pkgstrGetToken(&a, ...)
 *		a_string - [RO, *RO] - (char *)
 *			- pointer to string to extract token from
 *		a_index - [RO, *RO] - (int)
 *			- Index of token to return; '0' is first matching
 *			  token, '1' is second matching token, etc.
 *		a_separators - [RO, *RO] - (char *)
 *			- String containing one or more characters that
 *			  can separate one "token" from another
 *		a_buf - [RO, *RW] - (char *)
 *			- Pointer to buffer used as storage space for the
 *			  returned token - the returned token is always
 *			  null terminated
 *			  a_buf[0] == '\0' - no token meeting criteria found
 *			  a_buf[0] != '\0' - token meeting criteria returned
 *		a_bufLen - [RO, *RO] - (int)
 *			- Size of 'a_buf' in bytes - a maximum of 'a_bufLen-1'
 *			  bytes will be placed in 'a_buf' - the returned
 *			  token is always null terminated
 * Returns:	void
 */

void
pkgstrGetToken_r(char *r_sep, char *a_string, int a_index,
	char *a_separators, char *a_buf, int a_bufLen)
{
	char	*p;
	char	*q;
	char	*lasts;

	/* entry assertions */

	assert(a_string != (char *)NULL);
	assert(a_index >= 0);
	assert(a_separators != (char *)NULL);
	assert(*a_separators != '\0');
	assert(a_buf != (char *)NULL);
	assert(a_bufLen > 0);

	/* reset returned separator */

	if (r_sep != (char *)NULL) {
		*r_sep = '\0';
	}

	/* zero out contents of return buffer */

	bzero(a_buf, a_bufLen);

	/* duplicate original string before breaking down into tokens */

	p = strdup(a_string);
	assert(p != (char *)NULL);
	if (p == (char *)NULL) {
		return;
	}
	lasts = p;

	/* scan for separators and return 'index'th token found */

	while (q = strtok_r((char *)NULL, a_separators, &lasts)) {
		/* retrieve separator if requested */

		if (r_sep != (char *)NULL) {
			char	*x;
			x = strpbrk(a_string, a_separators);
			if (x) {
				*r_sep = *x;
			}
		}

		/* if this is the 'index'th token requested return it */

		if (a_index-- == 0) {
			/* copy as many characters as possible to return buf */

			(void) strncpy(a_buf, q, a_bufLen-1);
			break;
		}
	}

	/* free up copy of original input string */

	free(p);
}

/*
 * Name:	pkgstrAddToken
 * Synopsis:	Add a token to a string
 * Description:	Append a token (sequence of one or more characters) to a
 *		string that is in allocated space - create new string if
 *		no string to append to exists
 * Arguments:	a_old - [RO, *RW] - (char **)
 *			- Pointer to handle to string to append token to
 *			  == (char *)NULL - new string is created
 *		a_new - [RO, *RO] - (char *)
 *			- Pointer to string representing token to append
 *			  to the end of the "a_old" string
 *			  == (char *)NULL - no action is performed
 *			  a_new[0] == '\0' - no action is performed
 *		a_separator - [RO, *RO] - (char)
 *			- One character placed between the old (existing)
 *			  string and the new token to be added IF the old
 *			  string exists and is not empty (zero length)
 * Returns:	void
 * CAUTION:	The old (existing) string must be allocated space (via lu_mem*
 *		or pkgstr* methods) - it must not be a static or inline
 *		character string
 * NOTE:	The old (existing) string may be freed with 'free'
 *		if a token is appended to it
 * NOTE:    	Any string returned in 'a_old' is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the token string is no longer needed.
 */

void
pkgstrAddToken(char **a_old, char *a_new, char a_separator)
{
	/* entry assertions */

	assert(a_old != (char **)NULL);
	assert(a_separator != '\0');

	/* if token to add is null, just return */

	if (a_new == (char *)NULL) {
		return;
	}

	/* if token to add is empty (zero length), just return */

	if (*a_new == '\0') {
		return;
	}

	/* make sure that new token does not contain the separator */

	assert(strchr(a_new, (int)a_separator) == (char *)NULL);

	/* if old string is empty (zero length), deallocate */

	if ((*a_old != (char *)NULL) && ((*a_old)[0] == '\0')) {
		/* *a_old is set to NULL by free */
		free(*a_old);
		*a_old = (char *)NULL;
	}

	/* if old string is exists, append separator and token */

	if (*a_old != (char *)NULL) {
		char *p;
		p = pkgstrPrintf("%s%c%s", *a_old, a_separator, a_new);
		free(*a_old);
		*a_old = p;
		return;
	}

	/* old string does not exist - return duplicate of token */

	assert(*a_old == (char *)NULL);
	*a_old = strdup(a_new);
	assert(*a_old != (char *)NULL);
}

/*
 * Name:	pkgstrContainsToken
 * Synopsis:	Does a given string contain a specified substring
 * Description:	Determine if a given substring exists in a larger string
 * Arguments:	a_string - [RO, *RO] - (char *)
 *			Pointer to string to look for substring in
 *		a_token - [RO, *RO] - (char *)
 *			Pointer to substring to look for in larger string
 * Results:	boolean_t
 *			B_TRUE - substring exists in larger string
 *			B_FALSE - substring does NOT exist in larger string
 * NOTE:	The substring must match on a "token" basis; that is, the
 *		substring must exist in the larger string delineated with
 *		either spaces or tabs to match.
 */

boolean_t
pkgstrContainsToken(char *a_string, char *a_token, char *a_separators)
{
	char	*lasts;
	char	*current;
	char	*p;

	/* entry assertions */

	assert(a_separators != (char *)NULL);
	assert(*a_separators != '\0');

	/* if token is not supplied, return false */

	if (a_token == (char *)NULL) {
		return (B_FALSE);
	}

	/* if no string provided, return false */

	if (a_string == (char *)NULL) {
		return (B_FALSE);
	}

	/* if string empty (zero length), return false */

	if (*a_string == '\0') {
		return (B_FALSE);
	}

	/* duplicate larger string because strtok_r changes it */

	p = strdup(a_string);
	assert(p != (char *)NULL);
	if (p == (char *)NULL) {
		return (B_FALSE);
	}

	lasts = p;

	/* scan each token looking for a match */

	while ((current = strtok_r((char *)NULL, a_separators, &lasts)) !=
			(char *)NULL) {
		if (streq(current, a_token)) {
			free(p);
			return (B_TRUE);
		}
	}

	/* free up temporary storage */

	free(p);

	/* not found */

	return (B_FALSE);
}

/*
 * Name:	pkgstrRemoveToken
 * Synopsis:	Remove a token from a string
 * Description:	Remove a token (sequence of one or more characters) from a
 *		string that is in allocated space
 * Arguments:	r_string - [RO, *RW] - (char **)
 *			- Pointer to handle to string to remove token from
 *		a_token - [RO, *RO] - (char *)
 *			Pointer to token (substring) to look for and remove
 *			from r_string provided
 *		a_separators - [RO, *RO] - (char *)
 *			- String containing one or more characters that
 *			  separate one "token" from another in r_string
 *		a_index - [RO, *RO] - (int)
 *			- Index of token to remove; '0' is first matching
 *			  token, '1' is second matching token, etc.
 * Returns:	void
 * CAUTION:	The input string must be allocated space (via lu_mem* or
 *		pkgstr* methods) - it must not be a static or inline
 *		character string
 * NOTE:	The input string r_string will be freed with 'free'
 *		if the token to be removed is found
 * NOTE:    	Any token string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the token string is no longer needed.
 * Errors:	If the new token string cannot be created, the process exits
 */

void
pkgstrRemoveToken(char **r_string, char *a_token, char *a_separators,
	int a_index)
{
	char	*a_string;
	char	*copyString;
	char	sep = 0;
	int	copyLength;
	int	i;

	/* entry assertions */

	assert(r_string != (char **)NULL);
	assert(a_token != (char *)NULL);
	assert(*a_token != '\0');
	assert(a_separators != (char *)NULL);
	assert(*a_separators != '\0');

	/* simple case: input string is null; return empty string */

	a_string = *r_string;
	if (*a_string == '\0') {
		return;
	}

	/* simple case: token == input string; return empty string */

	if (streq(a_string, a_token)) {
		/* deallocate input string; free sets *r_string to NULL */

		free(*r_string);
		*r_string = (char *)NULL;
		return;
	}

	/* simple case: token not in input string: return */

	if (!pkgstrContainsToken(a_string, a_token, a_separators)) {
		return;
	}

	/*
	 * Pick apart the old string building the new one as we go along
	 * removing the first occurance of the token provided
	 */

	copyLength = (strlen(a_string)-strlen(a_token))+2;
	copyString = calloc(1, copyLength);
	assert(copyString != (char *)NULL);
	if (copyString == (char *)NULL) {
		return;
	}

	for (i = 0; ; i++) {
		char	*p;

		p = pkgstrGetToken(&sep, a_string, i, a_separators);
		if (p == (char *)NULL) {
			break;
		}

		if (streq(p, a_token) && (a_index-- == 0)) {
			continue;
		}

		if (*copyString) {
			assert(sep != '\0');
			(void) strncat(copyString, &sep, 1);
		}

		(void) strcat(copyString, p);
	}

	free(*r_string);
	assert(*copyString);
	*r_string = copyString;
}

/*
 * Name:	pkgstrScaleNumericString
 * Synopsis:	Convert unsigned long long to human readable form
 * Description:	Convert a string containing an unsigned long long representation
 *		and convert it into a human readable numeric string. The number
 *		is scaled down until it is small enough to be in a good human
 *		readable format i.e. in the range 0 thru scale-1.
 * Arguments:	a_buf - [RO, *RW] - (char *)
 *			Pointer to buffer containing string representation
 *			of unsigned long long to convert
 *		scale - [RO, *RO] - (unsigned long long)
 *			Value to scale the number into
 * Returns:	a_buf - contains human readable scaled representation of
 *			original value contained in the buffer
 * Note:	The value "(unsigned long long)-1" is a special case and
 *		is always converted to "-1".
 * Errors:	If the string cannot be created, the process exits
 */

void
pkgstrScaleNumericString(char *a_buf, unsigned long long scale)
{
static char		*M = " KMGTPE"; /* Measurement: */
					/* kilo, mega, giga, tera, peta, exa */

	unsigned long long number = 0;	/* convert this number */
	unsigned long long save = 0;
	char	*uom = M;    /* unit of measurement, initially ' ' (=M[0]) */

	/* entry assertions */

	assert(scale > (unsigned long long)0);
	assert(scale <=  (unsigned long long)1048576);

	/*
	 * Get the number - if no number of empty number, just return
	 */

	if (a_buf == (char *)NULL) {
		return;
	}

	if (*a_buf == '\0') {
		(void) strcpy(a_buf, "0");
		return;
	}

	/* convert out the number from the input buffer */

	number = strtoull(a_buf, (char **)NULL, 10);

	/* if conversion error, return "-1" */

	if ((long long)number == (long long)-1) {
		(void) strcpy(a_buf, "-1");
		return;
	}

	/*
	 * Now have number as a count of scale units.
	 * Stop scaling when we reached exa-bytes, then something is
	 * probably wrong with our number (it is improbably large)
	 */

	while ((number >= scale) && (*uom != 'E')) {
		uom++; /* next unit of measurement */
		save = number;
		number = (number + (scale / 2)) / scale;
	}

	/* check if we should output a decimal place after the point */

	if (save && ((save / scale) < 10)) {
		/* sprintf() will round for us */
		float fnum = (float)save / scale;
		(void) sprintf(a_buf, "%4.1f%c", fnum, *uom);
	} else {
		(void) sprintf(a_buf, "%4llu%c", number, *uom);
	}
}

/*
 * Name:	pkgstrLocatePathBasename
 * Synopsis:	Locate position of base name in path string
 * Description:	Locate the base name (last path item) in a path and
 *		return a pointer to the first byte of the base name
 *		within the given path
 * Arguments:	a_path - [RO, *RO] - (char *)
 *			- Pointer to string representing path to scan
 * Returns:	char *
 *			- Pointer into string of first byte of path base name
 *			- == (char *)NULL - input path is (char *)NULL
 */

char *
pkgstrLocatePathBasename(char *a_path)
{
	char	*p;

	/* if path is NULL, return NULL */

	if (!a_path) {
		return (a_path);
	}

	/* locate last occurance of '/' in path */

	p = strrchr(a_path, '/');
	if (p != (char *)NULL) {
		/* base name located - return -> first byte */
		return (p+1);
	}

	/* no occurance of '/' - entry path must be basename */

	return (a_path);
}

/*
 * Name:	pkgstrConvertPathToBasename
 * Synopsis:	Return copy of base name in path string
 * Description:	Locate the base name (last path item) in a path and
 *		return a copy of the base name in allocated storage
 * Arguments:	a_path - [RO, *RO] - (char *)
 *			- Pointer to string representing path to scan
 * Returns:	char *
 *			- String containing path base name
 *			- == (char *)NULL - input path is (char *)NULL
 * NOTE:    	Any string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the string is no longer needed.
 * Errors:	If the string cannot be created, the process exits
 */

char *
pkgstrConvertPathToBasename(char *a_path)
{
	char	*p;

	/* if path is NULL, return NULL */

	if (a_path == (char *)NULL) {
		return ((char *)NULL);
	}

	/* if path is empty (zero length), return NULL */

	if (*a_path == '\0') {
		return ((char *)NULL);
	}

	/* locate last occurance of '/' in path */

	p = strrchr(a_path, '/');
	if (p == (char *)NULL) {
		/* no occurance of '/' - entry path must be basename */

		return (strdup(a_path));
	}

	/* base name located - return string from -> first byte */

	return (strdup(p+1));
}

/*
 * Name:	pkgstrConvertPathToDirname
 * Synopsis:	Return copy of directory in path string
 * Description:	Locate the directory name (everything but last path item) in a
 *		path and return a copy of the dir name in allocated storage
 * Arguments:	a_path - [RO, *RO] - (char *)
 *			- Pointer to string representing path to scan
 * Returns:	char *
 *			- String containing path directory name
 *			- == (char *)NULL - input path is (char *)NULL,
 *			  or a_path is empty (*a_path == '\0'), or the
 *			  a_path has no directory name in it.
 * NOTE:    	Any string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the string is no longer needed.
 * Errors:	If the string cannot be created, the process exits
 */

char *
pkgstrConvertPathToDirname(char *a_path)
{
	char	*p;
	char	*retPath;

	/* if path is NULL, return NULL */

	if (a_path == (char *)NULL) {
		return ((char *)NULL);
	}

	/* if path is empty (zero length), return NULL */

	if (*a_path == '\0') {
		return ((char *)NULL);
	}

	/* locate last occurance of '/' in path */

	p = strrchr(a_path, '/');
	if (p == (char *)NULL) {
		/* no occurance of '/' - entire path must be basename */

		return ((char *)NULL);
	}

	/* duplicate original path */

	retPath = strdup(a_path);
	assert(retPath != (char *)NULL);
	if (retPath == (char *)NULL) {
		return ((char *)NULL);
	}

	/* remove all trailing '/'s from copy of path */

	for (p = strrchr(retPath, '/');	(p > retPath) && (*p == '/'); p--) {
		*p = '\0';
	}

	/* if entire path was '/'s, return null string - no directory present */

	if (*retPath == '\0') {
		free(retPath);
		return ((char *)NULL);
	}

	/* path has at least one non-'/' in it - return -> directory portion */

	return (retPath);
}

/*
 * Name:	pkgstrConvertUllToTimeString_r
 * Synopsis:	Convert an unsigned long long into a "time string"
 * Description:	Given an unsigned long long, return a "time string" which is a
 *		conversion of the unsigned long long interpreted as a number of
 *		nanoseconds into a "hour:minute:second.ns" ascii string
 * Arguments:	a_time - [RO, *RO] - (unsigned long long)n
 *			- value to convert
 *		a_buf - [RO, *RW] - (char *)
 *			- Pointer to buffer used as storage space for the
 *			  returned string
 *		a_bufLen - [RO, *RO] - (int)
 *			- Size of 'a_buf' in bytes - a maximum of 'a_bufLen-1'
 *			  bytes will be placed in 'a_buf'
 * Returns:	char *
 *			- String containing converted value
 * NOTE:    	Any string returned is placed in new storage for the
 *		calling method. The caller must use 'free' to dispose
 *		of the storage once the string is no longer needed.
 * Errors:	If the string cannot be created, the process exits
 */

void
pkgstrConvertUllToTimeString_r(unsigned long long a_time,
	char *a_buf, int a_bufLen)
{
	unsigned long long	seconds;
	unsigned long long	minutes;
	unsigned long long	hours;
	unsigned long long	ns;

	/* entry assertions */

	assert(a_buf != (char *)NULL);
	assert(a_bufLen > 0);

	/* if time is 0, return immediate result */

	if (a_time == 0) {
		pkgstrPrintf_r(a_buf, a_bufLen, "%s", "0:00:00.000000000");
		return;
	}

	/* break out individual time components */

	ns = a_time % 1000000000ll;	/* nanoseconds left over from seconds */
	seconds = a_time / 1000000000ll;	/* total seconds */
	minutes = seconds / 60ll;	/* total minutes */
	seconds = seconds % 60ll;	/* seconds left over from minutes */
	hours = minutes / 60ll;		/* total hours */
	minutes = minutes % 60ll;	/* minutes left over from hours */

	/* return a converted string */

	pkgstrPrintf_r(a_buf, a_bufLen, "%llu:%02llu:%02llu.%09llu",
						hours, minutes, seconds, ns);
}