8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / lib / libinstzones / common / zones_str.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:      zones_str.c
 * Group:       libinstzones
 * Description: Private functions used by zones library functions to manipulate
 *              strings
 *
 * Public Methods:
 *
 * _z_strAddToken - Add a token to a string
 * _z_strContainsToken - Does a given string contain a specified substring
 * _z_strGetToken - Get a separator delimited token from a string
 * _z_strGetToken_r - Get separator delimited token from string to fixed buffer
 * _z_strPrintf - Create string from printf style format and arguments
 * _z_strPrintf_r - Create string from printf style format and arguments
 * _z_strRemoveLeadingWhitespace - Remove leading whitespace from string
 * _z_strRemoveToken - Remove a token from a string
 */

/*
 * System includes
 */

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

/*
 * local includes
 */

#include "instzones_lib.h"
#include "zones_strings.h"

/*
 * Private structures
 */

/*
 * Library Function Prototypes
 */

/*
 * Local Function Prototypes
 */

/*
 * Global internal (private) declarations
 */

/*
 * *****************************************************************************
 * global external (public) functions
 * *****************************************************************************
 */

/*
 * Name:        _z_strAddToken
 * 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
 *                        == 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
 *                        == 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 _z_str* 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
_z_strAddToken(char **a_old, char *a_new, char a_separator)
{
        /* entry assertions */

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

        /* if token to add is null or token is zero length, just return */

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

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

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

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

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

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

        if (*a_old != NULL) {
                char *p;
                p = _z_strPrintf("%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 == NULL);
        *a_old = _z_strdup(a_new);
}

/*
 * Name:        _z_strContainsToken
 * 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
_z_strContainsToken(char *a_string, char *a_token, char *a_separators)
{
        char    *lasts;
        char    *current;
        char    *p;

        /* entry assertions */

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

        /*
         * if token is not supplied, no string provided,
         * or the string is an empty string, return false
         */

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

        /* if no string provided, return false */

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

        /* duplicate larger string because strtok_r changes it */

        p = _z_strdup(a_string);

        lasts = p;

        /* scan each token looking for a match */

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

        /* free up temporary storage */

        free(p);

        /* not found */

        return (B_FALSE);
}

/*
 * Name:        _z_strGetToken
 * 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;
 *                              - _z_strGetToken(&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 *
 *                      == NULL - no token matching criteria found
 *                      != 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 *
_z_strGetToken(char *r_sep, char *a_string, int a_index, char *a_separators)
{
        char    *p;
        char    *q;
        char    *lasts;

        /* entry assertions */

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

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

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

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

        p = _z_strdup(a_string);

        lasts = p;

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

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

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

                        x = strpbrk(a_string, a_separators);
                        if (x != NULL) {
                                *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 = _z_strdup(q);

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

/*
 * Name:        _z_strGetToken_r
 * 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;
 *                              - _z_strGetToken(&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
_z_strGetToken_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 != NULL);
        assert(a_index >= 0);
        assert(a_separators != NULL);
        assert(*a_separators != '\0');
        assert(a_buf != NULL);
        assert(a_bufLen > 0);

        /* reset returned separator */

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

        /* zero out contents of return buffer */

        bzero(a_buf, a_bufLen);

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

        p = _z_strdup(a_string);

        lasts = p;

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

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

                if (r_sep != NULL) {
                        char    *x;
                        x = strpbrk(a_string, a_separators);
                        if (x != NULL) {
                                *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:        _z_strPrintf
 * 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 *
_z_strPrintf(char *a_format, ...)
{
        va_list         ap;
        size_t          vres = 0;
        char            bfr[1];
        char            *rstr = NULL;

        /* entry assertions */

        assert(a_format != 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 *)_z_calloc(vres+2);

        /* 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:        _z_strPrintf_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
_z_strPrintf_r(char *a_buf, int a_bufLen, char *a_format, ...)
{
        va_list         ap;
        size_t          vres = 0;

        /* entry assertions */

        assert(a_format != NULL);
        assert(*a_format != '\0');
        assert(a_buf != 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:        _z_strRemoveLeadingWhitespace
 * 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:
 *                      == NULL:
 *                              - input string was NULL
 *                              - input string is all whitespace
 *                      != NULL:
 *                              - copy of input string with leading
 *                                whitespace removed
 * CAUTION:     The input string must be allocated space (via mem* or
 *              _z_str* 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
_z_strRemoveLeadingWhitespace(char **a_str)
{
        char    *o_str;

        /* entry assertions */

        assert(a_str != NULL);

        /* if string is null, just return */

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

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

        if (*o_str == '\0') {
                /* free string - handle is not reset to NULL by free */
                free(*a_str);
                *a_str = 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 not reset to NULL by free */
                free(*a_str);
                *a_str = NULL;
                return;
        }

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

        free(*a_str);
        *a_str = _z_strdup(o_str);
}

/*
 * Name:        _z_strRemoveToken
 * 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
 *              _z_str* 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
_z_strRemoveToken(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 != NULL);
        assert(a_token != NULL);
        assert(*a_token != '\0');
        assert(a_separators != 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 (strcmp(a_string, a_token) == 0) {
                /*
                 * deallocate input string; free doesn't
                 * set *r_string to NULL
                 */
                free(*r_string);
                *r_string = NULL;
                return;
        }

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

        if (!_z_strContainsToken(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 = (char *)_z_calloc(copyLength);

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

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

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

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

                (void) strcat(copyString, p);
                free(p);
        }

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