OpenSolaris_b135/lib/libpkg/common/pkgstr.c
/*
* 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);
}