/* BEGIN_ICS_COPYRIGHT5 ****************************************

Copyright (c) 2015-2017, Intel Corporation

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
    * Neither the name of Intel Corporation nor the names of its contributors
      may be used to endorse or promote products derived from this software
      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 * ** END_ICS_COPYRIGHT5   ****************************************/

/***********************************************************************
* 
* FILE NAME
*      cs_string.c
*
* DESCRIPTION
*      This file contains the implementation of the String Conversion
*      services.
*
* DATA STRUCTURES
*
* FUNCTIONS
*      cs_strtoui8
*      cs_strtoui16
*      cs_strtoui32
*      cs_strtoui64
*      cs_strtoi8
*      cs_strtoi16
*      cs_strtoui32
*      cs_strtoi64
*      cs_parse_gid
*
* DEPENDENCIES
*      cs_g.h
*
*
* HISTORY
*
* NAME      DATE        REMARKS
* MGR       05/01/02    PR1754.  Initial creation of file.
* MGR       05/06/02    PR1754.  Added support for functions.
* MGR       05/07/02    PR1812.  Clean-up lint errors.
*
***********************************************************************/
#include "ib_types.h"
#include "ib_status.h"
#include "cs_g.h"
#include "vs_g.h"
#include "cs_log.h"
#include <stdarg.h>
#define function __FUNCTION__
#ifdef LOCAL_MOD_ID
#undef LOCAL_MOD_ID
#endif
#define LOCAL_MOD_ID VIEO_CS_MOD_ID




/**********************************************************************
*
* FUNCTION
*    cs_strtoui8
*
* DESCRIPTION
*    Convert a string to an unsigned 8-bit integer.
*
* INPUTS
*    nptr         - A pointer to the string to convert.
*    return_error - Value to return on error.
*
* OUTPUTS
*    cvalue       - On success, the converted value is returned.
*
*
* HISTORY
*
*   NAME    DATE        REMARKS
*   MGR     05/01/02    Initial creation of function.
*
**********************************************************************/
uint8_t
cs_strtoui8 (const char *nptr, uint8_t return_error)
{
  uint32_t          base = 0;
  int               overflow = 0;
  uint8_t           digit;
  uint8_t           cvalue = 0;
  uint32_t          maxdiv;
  uint32_t          maxrem;

  IB_ENTER (function,
            (unint)nptr,
            (uint32_t)return_error,
            (uint32_t)0U,
	    (uint32_t)0U);

  /*
  ** Validate string pointer
  */
  if (nptr == (char *)0)
  {
    IB_LOG_ERROR0 ("NULL pointer");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
  ** Skip leading spaces
  */
  while (*nptr == ' ')
  {
    nptr++;
  }

  /*
  ** Allow a leading '+'; however negative values are not allowed.
  */
  if (*nptr == '+')
  {
    nptr++;
  }
  else if (*nptr == '-')
  {
    IB_LOG_ERROR0 ("negative values are invalid");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
   * Determine the base
   */
  if (*nptr != '0')
  {
    /* decimal string */
    base = 10;
    IB_LOG_INFO ("string is decimal", (uint32_t)base);
  }
  else
  {
    /* first 'real' character is a 0 */
    if (nptr[1] == 'X' || nptr[1] == 'x')
    {
      /* hexadecimal string */
      base = 16;
      nptr += 2;
      IB_LOG_INFO ("string is hexadecimal", (uint32_t)base);
    }
    else
    {
      /* decimal string */
      base = 10;
      IB_LOG_INFO ("string is decimal", (uint32_t)base);
    }
  }

  maxdiv = UINT8_MAX / base;
  maxrem = UINT8_MAX % base;

  while ((digit = *nptr) != '\0')
  {
    if (digit >= '0' && digit < ('0' + base))
    {
      digit -= '0';
    }
    else
    {
      if (base > 10)
      {
        if (digit >= 'a' && digit < ('a' + (base - 10)))
        {
          digit = digit - 'a' + 10;
        }
        else if (digit >= 'A' && digit < ('A' + (base - 10)))
        {
          digit = digit - 'A' + 10;
        }
        else
        {
          IB_LOG_ERROR ("invalid digit:", (uint32_t)digit);
          IB_EXIT (function, (uint32_t)return_error);
          return return_error;
        }
      }
      else
      {
        IB_LOG_ERROR ("invalid digit:", (uint32_t)digit);
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }

    if (cvalue > maxdiv || (cvalue == maxdiv && digit > maxrem))
    {
      overflow = 1;
    }

    cvalue = (cvalue * base) + digit;
    nptr++;
  }
	
  if (overflow)
  {
    IB_LOG_ERROR0 ("string value is too large");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  IB_EXIT (function, (uint32_t)cvalue);
  return cvalue;
}

/**********************************************************************
*
* FUNCTION
*    cs_strtoui16
*
* DESCRIPTION
*    Convert a string to an unsigned 16-bit integer.
*
* INPUTS
*    nptr         - A pointer to the string to convert.
*    return_error - Value to return on error.
*
* OUTPUTS
*    cvalue       - On success, the converted value is returned.
*
*
* HISTORY
*
*   NAME    DATE        REMARKS
*   MGR     05/01/02    Initial creation of function.
*
**********************************************************************/
uint16_t
cs_strtoui16 (const char *nptr, uint16_t return_error)
{
  uint32_t          base = 0;
  int               overflow = 0;
  uint8_t           digit;
  uint16_t          cvalue = 0;
  uint32_t          maxdiv;
  uint32_t          maxrem;

  IB_ENTER (function,
            (unint)nptr,
            (uint32_t)return_error,
            (uint32_t)0U,
	    (uint32_t)0U);

  /*
  ** Validate string pointer
  */
  if (nptr == (char *)0)
  {
    IB_LOG_ERROR0 ("NULL pointer");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
  ** Skip leading spaces
  */
  while (*nptr == ' ')
  {
    nptr++;
  }

  /*
  ** Allow a leading '+'; however negative values are not allowed.
  */
  if (*nptr == '+')
  {
    nptr++;
  }
  else if (*nptr == '-')
  {
    IB_LOG_ERROR0 ("negative values are invalid");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
   * Determine the base
   */
  if (*nptr != '0')
  {
    /* decimal string */
    base = 10;
    IB_LOG_INFO ("string is decimal", (uint32_t)base);
  }
  else
  {
    /* first 'real' character is a 0 */
    if (nptr[1] == 'X' || nptr[1] == 'x')
    {
      /* hexadecimal string */
      base = 16;
      nptr += 2;
      IB_LOG_INFO ("string is hexadecimal", (uint32_t)base);
    }
    else
    {
      /* decimal string */
      base = 10;
      IB_LOG_INFO ("string is decimal", (uint32_t)base);
    }
  }

  maxdiv = UINT16_MAX / base;
  maxrem = UINT16_MAX % base;

  while ((digit = *nptr) != '\0')
  {
    if (digit >= '0' && digit < ('0' + base))
    {
      digit -= '0';
    }
    else
    {
      if (base > 10)
      {
        if (digit >= 'a' && digit < ('a' + (base - 10)))
        {
          digit = digit - 'a' + 10;
        }
        else if (digit >= 'A' && digit < ('A' + (base - 10)))
        {
          digit = digit - 'A' + 10;
        }
        else
        {
          IB_LOG_ERROR ("invalid digit:", (uint32_t)digit);
          IB_EXIT (function, (uint32_t)return_error);
          return return_error;
        }
      }
      else
      {
        IB_LOG_ERROR ("invalid digit:", (uint32_t)digit);
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }

    if (cvalue > maxdiv || (cvalue == maxdiv && digit > maxrem))
    {
      overflow = 1;
    }

    cvalue = (cvalue * base) + digit;
    nptr++;
  }
	
  if (overflow)
  {
    IB_LOG_ERROR0 ("string value is too large");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  IB_EXIT (function, (uint32_t)cvalue);
  return cvalue;
}

/**********************************************************************
*
* FUNCTION
*    cs_strtoui32
*
* DESCRIPTION
*    Convert a string to an unsigned 32-bit integer.
*
* INPUTS
*    nptr         - A pointer to the string to convert.
*    return_error - Value to return on error.
*
* OUTPUTS
*    cvalue       - On success, the converted value is returned.
*
*
* HISTORY
*
*   NAME    DATE        REMARKS
*   MGR     05/01/02    Initial creation of function.
*
**********************************************************************/
uint32_t
cs_strtoui32 (const char *nptr, uint32_t return_error)
{
  uint32_t          base = 0;
  int               overflow = 0;
  uint8_t           digit;
  uint32_t          cvalue = 0;
  uint32_t          maxdiv;
  uint32_t          maxrem;

  IB_ENTER (function,
            (unint)nptr,
            (uint32_t)return_error,
            (uint32_t)0U,
	    (uint32_t)0U);

  /*
  ** Validate string pointer
  */
  if (nptr == (char *)0)
  {
    IB_LOG_ERROR0 ("NULL pointer");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
  ** Skip leading spaces
  */
  while (*nptr == ' ')
  {
    nptr++;
  }

  /*
  ** Allow a leading '+'; however negative values are not allowed.
  */
  if (*nptr == '+')
  {
    nptr++;
  }
  else if (*nptr == '-')
  {
    IB_LOG_ERROR0 ("negative values are invalid");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
   * Determine the base
   */
  if (*nptr != '0')
  {
    /* decimal string */
    base = 10;
    IB_LOG_INFO ("string is decimal", (uint32_t)base);
  }
  else
  {
    /* first 'real' character is a 0 */
    if (nptr[1] == 'X' || nptr[1] == 'x')
    {
      /* hexadecimal string */
      base = 16;
      nptr += 2;
      IB_LOG_INFO ("string is hexadecimal", (uint32_t)base);
    }
    else
    {
      /* decimal string */
      base = 10;
      IB_LOG_INFO ("string is decimal", (uint32_t)base);
    }
  }

  maxdiv = UINT32_MAX / base;
  maxrem = UINT32_MAX % base;

  while ((digit = *nptr) != '\0')
  {
    if (digit >= '0' && digit < ('0' + base))
    {
      digit -= '0';
    }
    else
    {
      if (base > 10)
      {
        if (digit >= 'a' && digit < ('a' + (base - 10)))
        {
          digit = digit - 'a' + 10;
        }
        else if (digit >= 'A' && digit < ('A' + (base - 10)))
        {
          digit = digit - 'A' + 10;
        }
        else
        {
          IB_LOG_ERROR ("invalid digit:", (uint32_t)digit);
          IB_EXIT (function, (uint32_t)return_error);
          return return_error;
        }
      }
      else
      {
        IB_LOG_ERROR ("invalid digit:", (uint32_t)digit);
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }

    if (cvalue > maxdiv || (cvalue == maxdiv && digit > maxrem))
    {
      overflow = 1;
    }

    cvalue = (cvalue * base) + digit;
    nptr++;
  }
	
  if (overflow)
  {
    IB_LOG_ERROR0 ("string value is too large");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  IB_EXIT (function, (uint32_t)cvalue);
  return cvalue;
}

/**********************************************************************
*
* FUNCTION
*    cs_strtoui64
*
* DESCRIPTION
*    Convert a string to an unsigned 64-bit integer.
*
* INPUTS
*    nptr         - A pointer to the string to convert.
*    return_error - Value to return on error.
*
* OUTPUTS
*    cvalue       - On success, the converted value is returned.
*
*
* HISTORY
*
*   NAME    DATE        REMARKS
*   MGR     05/01/02    Initial creation of function.
*   PJG     05/28/02    PR2166 Suffix 64-bit constants with ll to
*                         eliminate warnings.
*
**********************************************************************/
uint64_t
cs_strtoui64 (const char *nptr, uint64_t return_error)
{
  uint32_t          base = 0;
  int               overflow = 0;
  uint8_t           digit;
  uint64_t          cvalue = 0;
  uint64_t          maxdiv = 0;
  uint64_t          maxrem = 0;

  IB_ENTER (function,
            (unint)nptr,
            (uint32_t)return_error,
            (uint32_t)0U,
	    (uint32_t)0U);

  /*
  ** Validate string pointer
  */
  if (nptr == (char *)0)
  {
    IB_LOG_ERROR0 ("NULL pointer");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
  ** Skip leading spaces
  */
  while (*nptr == ' ')
  {
    nptr++;
  }

  /*
  ** Allow a leading '+'; however negative values are not allowed.
  */
  if (*nptr == '+')
  {
    nptr++;
  }
  else if (*nptr == '-')
  {
    IB_LOG_ERROR0 ("negative values are invalid");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
   * Determine the base
   */
  if (*nptr != '0')
  {
    /* decimal string */
    base = 10;
    IB_LOG_INFO ("string is decimal", (uint32_t)base);
  }
  else
  {
    /* first 'real' character is a 0 */
    if (nptr[1] == 'X' || nptr[1] == 'x')
    {
      /* hexadecimal string */
      base = 16;
      nptr += 2;
      IB_LOG_INFO ("string is hexadecimal", (uint32_t)base);
    }
    else
    {
      /* decimal string */
      base = 10;
      IB_LOG_INFO ("string is decimal", (uint32_t)base);
    }
  }

  /* Hardcode these values since it causes module load errors */
  if (base == 10)
  {
    maxdiv = 1844674407370955161ll;
    maxrem = 5;
  }
  else if (base == 16)
  {
    maxdiv = 1152921504606846975ll;
    maxrem = 15;
  }

  while ((digit = *nptr) != '\0')
  {
    if (digit >= '0' && digit < ('0' + base))
    {
      digit -= '0';
    }
    else
    {
      if (base > 10)
      {
        if (digit >= 'a' && digit < ('a' + (base - 10)))
        {
          digit = digit - 'a' + 10;
        }
        else if (digit >= 'A' && digit < ('A' + (base - 10)))
        {
          digit = digit - 'A' + 10;
        }
        else
        {
          IB_LOG_ERROR ("invalid digit:", (uint32_t)digit);
          IB_EXIT (function, (uint32_t)return_error);
          return return_error;
        }
      }
      else
      {
        IB_LOG_ERROR ("invalid digit:", (uint32_t)digit);
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }

    if (cvalue > maxdiv || (cvalue == maxdiv && digit > maxrem))
    {
      overflow = 1;
    }

    cvalue = (cvalue * base) + digit;
    nptr++;
  }
	
  if (overflow)
  {
    IB_LOG_ERROR0 ("string value is too large");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  IB_EXIT (function, (uint32_t)cvalue);
  return cvalue;
}

/**********************************************************************
*
* FUNCTION
*    cs_strtoi8
*
* DESCRIPTION
*    Convert a string to a signed 8-bit integer.
*
* INPUTS
*    nptr         - A pointer to the string to convert.
*    return_error - Value to return on error.
*
* OUTPUTS
*    cvalue       - On success, the converted value is returned.
*
*
* HISTORY
*
*   NAME    DATE        REMARKS
*   MGR     05/01/02    Initial creation of function.
*
**********************************************************************/
int8_t
cs_strtoi8 (const char *nptr, int8_t return_error)
{
  int               base = 0;
  int               negate = 0;
  int8_t            cvalue = 0;
  int8_t            digit;

  IB_ENTER (function,
            nptr,
            (uint32_t)(int32_t)return_error,
            0U,
            0U);

  /*
  ** Validate string pointer
  */
  if (nptr == (char *)0)
  {
    IB_LOG_ERROR0 ("NULL pointer");
    IB_EXIT (function, (uint32_t)(int32_t)return_error);
    return return_error;
  }

  /*
  ** Skip leading spaces
  */
  while (*nptr == ' ')
  {
    nptr++;
  }

  /*
  ** Allow a leading '+'; however negative values are not allowed.
  */
  if (*nptr == '+')
  {
    nptr++;
  }
  else if (*nptr == '-')
  {
    negate = 1;
    nptr++;
  }

  /*
   * Determine the base
   */
  if (*nptr != '0')
  {
    /* decimal string */
    base = 10;
    IB_LOG_INFO ("string is decimal", (uint32_t)base);
  }
  else
  {
    /* first 'real' character is a 0 */
    if (nptr[1] == 'X' || nptr[1] == 'x')
    {
      /* hexadecimal string */
      base = 16;
      nptr += 2;
      IB_LOG_INFO ("string is hexadecimal", (uint32_t)base);
    }
    else
    {
      /* decimal string */
      base = 10;
      IB_LOG_INFO ("string is decimal", (uint32_t)base);
    }
  }

  while ((digit = *nptr) != '\0')
  {
    if (digit >= '0' && digit < ('0' + base))
    {
      digit -= '0';
    }
    else
    {
      if (base > 10)
      {
        if (digit >= 'a' && digit < ('a' + (base - 10)))
        {
          digit = digit - 'a' + 10;
        }
        else if (digit >= 'A' && digit < ('A' + (base - 10)))
        {
          digit = digit - 'A' + 10;
        }
        else
        {
          IB_LOG_ERROR ("invalid digit:", (uint32_t)(int32_t)digit);
          IB_EXIT (function, (uint32_t)(int32_t)return_error);
          return return_error;
        }
      }
      else
      {
        IB_LOG_ERROR ("invalid digit:", (uint32_t)(int32_t)digit);
        IB_EXIT (function, (uint32_t)(int32_t)return_error);
        return return_error;
      }
    }

    if (negate == 1)
    {
      digit = -digit;
      if ((cvalue > (INT8_MIN / base)) ||
          ((cvalue == (INT8_MIN / base)) && (digit >= (INT8_MIN % base))))
      {
        cvalue = cvalue * base;
        cvalue += digit;
      }
      else
      {
        IB_LOG_ERROR0 ("string value is too small");
        IB_EXIT (function, (uint32_t)(int32_t)return_error);
        return return_error;
      }
    }
    else
    {
      if ((cvalue < (INT8_MAX / base)) ||
          ((cvalue == (INT8_MAX / base)) && (digit <= (INT8_MAX % base))))
      {
        cvalue = cvalue * base;
        cvalue += digit;
      }
      else
      {
        IB_LOG_ERROR0 ("string value is too large");
        IB_EXIT (function, (uint32_t)(int32_t)return_error);
        return return_error;
      }
    }
    nptr++;
  }

  IB_EXIT (function, (uint32_t)(int32_t)cvalue);
  return cvalue;
}

/**********************************************************************
*
* FUNCTION
*    cs_strtoi16
*
* DESCRIPTION
*    Convert a string to a signed 16-bit integer.
*
* INPUTS
*    nptr         - A pointer to the string to convert.
*    return_error - Value to return on error.
*
* OUTPUTS
*    cvalue       - On success, the converted value is returned.
*
*
* HISTORY
*
*   NAME    DATE        REMARKS
*   MGR     05/01/02    Initial creation of function.
*
**********************************************************************/
int16_t
cs_strtoi16 (const char *nptr, int16_t return_error)
{
  int               base = 0;
  int               negate = 0;
  int16_t           cvalue = 0;
  int8_t            digit;

  IB_ENTER (function,
            (unint)nptr,
            (uint32_t)(int32_t)return_error,
            (uint32_t)0U,
	    (uint32_t)0U);

  /*
  ** Validate string pointer
  */
  if (nptr == (char *)0)
  {
    IB_LOG_ERROR0 ("NULL pointer");
    IB_EXIT (function, (uint32_t)(int32_t)return_error);
    return return_error;
  }

  /*
  ** Skip leading spaces
  */
  while (*nptr == ' ')
  {
    nptr++;
  }

  /*
  ** Allow a leading '+'; however negative values are not allowed.
  */
  if (*nptr == '+')
  {
    nptr++;
  }
  else if (*nptr == '-')
  {
    negate = 1;
    nptr++;
  }

  /*
   * Determine the base
   */
  if (*nptr != '0')
  {
    /* decimal string */
    base = 10;
    IB_LOG_INFO ("string is decimal", (uint32_t)base);
  }
  else
  {
    /* first 'real' character is a 0 */
    if (nptr[1] == 'X' || nptr[1] == 'x')
    {
      /* hexadecimal string */
      base = 16;
      nptr += 2;
      IB_LOG_INFO ("string is hexadecimal", (uint32_t)base);
    }
    else
    {
      /* decimal string */
      base = 10;
      IB_LOG_INFO ("string is decimal", (uint32_t)base);
    }
  }

  while ((digit = *nptr) != '\0')
  {
    if (digit >= '0' && digit < ('0' + base))
    {
      digit -= '0';
    }
    else
    {
      if (base > 10)
      {
        if (digit >= 'a' && digit < ('a' + (base - 10)))
        {
          digit = digit - 'a' + 10;
        }
        else if (digit >= 'A' && digit < ('A' + (base - 10)))
        {
          digit = digit - 'A' + 10;
        }
        else
        {
          IB_LOG_ERROR ("invalid digit:", (uint32_t)(int32_t)digit);
          IB_EXIT (function, (uint32_t)(int32_t)return_error);
          return return_error;
        }
      }
      else
      {
        IB_LOG_ERROR ("invalid digit:", (uint32_t)(int32_t)digit);
        IB_EXIT (function, (uint32_t)(int32_t)return_error);
        return return_error;
      }
    }

    if (negate == 1)
    {
      digit = -digit;
      if ((cvalue > (INT16_MIN / base)) ||
          ((cvalue == (INT16_MIN / base)) && (digit >= (INT16_MIN % base))))
      {
        cvalue = cvalue * base;
        cvalue += digit;
      }
      else
      {
        IB_LOG_ERROR0 ("string value is too small");
        IB_EXIT (function, (uint32_t)(int32_t)return_error);
        return return_error;
      }
    }
    else
    {
      if ((cvalue < (INT16_MAX / base)) ||
          ((cvalue == (INT16_MAX / base)) && (digit <= (INT16_MAX % base))))
      {
        cvalue = cvalue * base;
        cvalue += digit;
      }
      else
      {
        IB_LOG_ERROR0 ("string value is too large");
        IB_EXIT (function, (uint32_t)(int32_t)return_error);
        return return_error;
      }
    }
    nptr++;
  }

  IB_EXIT (function, (uint32_t)(int32_t)cvalue);
  return cvalue;
}

/**********************************************************************
*
* FUNCTION
*    cs_strtoi32
*
* DESCRIPTION
*    Convert a string to a signed 32-bit integer.
*
* INPUTS
*    nptr         - A pointer to the string to convert.
*    return_error - Value to return on error.
*
* OUTPUTS
*    cvalue       - On success, the converted value is returned.
*
*
* HISTORY
*
*   NAME    DATE        REMARKS
*   MGR     05/01/02    Initial creation of function.
*
**********************************************************************/
int32_t
cs_strtoi32 (const char *nptr, int32_t return_error)
{
  int               base = 0;
  int               negate = 0;
  int32_t           cvalue = 0;
  int8_t            digit;

  IB_ENTER (function,
            (unint)nptr,
            (uint32_t)return_error,
            (uint32_t)0U,
	    (uint32_t)0U);

  /*
  ** Validate string pointer
  */
  if (nptr == (char *)0)
  {
    IB_LOG_ERROR0 ("NULL pointer");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
  ** Skip leading spaces
  */
  while (*nptr == ' ')
  {
    nptr++;
  }

  /*
  ** Allow a leading '+'; however negative values are not allowed.
  */
  if (*nptr == '+')
  {
    nptr++;
  }
  else if (*nptr == '-')
  {
    negate = 1;
    nptr++;
  }

  /*
   * Determine the base
   */
  if (*nptr != '0')
  {
    /* decimal string */
    base = 10;
    IB_LOG_INFO ("string is decimal", (uint32_t)base);
  }
  else
  {
    /* first 'real' character is a 0 */
    if (nptr[1] == 'X' || nptr[1] == 'x')
    {
      /* hexadecimal string */
      base = 16;
      nptr += 2;
      IB_LOG_INFO ("string is hexadecimal", (uint32_t)base);
    }
    else
    {
      /* decimal string */
      base = 10;
      IB_LOG_INFO ("string is decimal", (uint32_t)base);
    }
  }

  while ((digit = *nptr) != '\0')
  {
    if (digit >= '0' && digit < ('0' + base))
    {
      digit -= '0';
    }
    else
    {
      if (base > 10)
      {
        if (digit >= 'a' && digit < ('a' + (base - 10)))
        {
          digit = digit - 'a' + 10;
        }
        else if (digit >= 'A' && digit < ('A' + (base - 10)))
        {
          digit = digit - 'A' + 10;
        }
        else
        {
          IB_LOG_ERROR ("invalid digit:", (uint32_t)(int32_t)digit);
          IB_EXIT (function, (uint32_t)return_error);
          return return_error;
        }
      }
      else
      {
        IB_LOG_ERROR ("invalid digit:", (uint32_t)(int32_t)digit);
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }

    if (negate == 1)
    {
      digit = -digit;
      if ((cvalue > (INT32_MIN / base)) ||
          ((cvalue == (INT32_MIN / base)) && (digit >= (INT32_MIN % base))))
      {
        cvalue = cvalue * base;
        cvalue += digit;
      }
      else
      {
        IB_LOG_ERROR0 ("string value is too small");
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }
    else
    {
      if ((cvalue < (INT32_MAX / base)) ||
          ((cvalue == (INT32_MAX / base)) && (digit <= (INT32_MAX % base))))
      {
        cvalue = cvalue * base;
        cvalue += digit;
      }
      else
      {
        IB_LOG_ERROR0 ("string value is too large");
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }
    nptr++;
  }

  IB_EXIT (function, (uint32_t)cvalue);
  return cvalue;
}

/**********************************************************************
*
* FUNCTION
*    cs_strtoi64
*
* DESCRIPTION
*    Convert a string to a signed 64-bit integer.
*
* INPUTS
*    nptr         - A pointer to the string to convert.
*    return_error - Value to return on error.
*
* OUTPUTS
*    cvalue       - On success, the converted value is returned.
*
*
* HISTORY
*
*   NAME    DATE        REMARKS
*   MGR     05/01/02    Initial creation of function.
*   PJG     05/28/02    PR2166 Suffix 64-bit constants with ll to
*                         eliminate warnings.
*
**********************************************************************/
int64_t
cs_strtoi64 (const char *nptr, int64_t return_error)
{
  int               base = 0;
  int               negate = 0;
  int8_t            digit;
  int64_t           cvalue = 0;

  IB_ENTER (function,
            (unint)nptr,
            (uint32_t)return_error,
            (uint32_t)0U,
	    (uint32_t)0U);

  /*
  ** Validate string pointer
  */
  if (nptr == (char *)0)
  {
    IB_LOG_ERROR0 ("NULL pointer");
    IB_EXIT (function, (uint32_t)return_error);
    return return_error;
  }

  /*
  ** Skip leading spaces
  */
  while (*nptr == ' ')
  {
    nptr++;
  }

  /*
  ** Allow a leading '+'; however negative values are not allowed.
  */
  if (*nptr == '+')
  {
    nptr++;
  }
  else if (*nptr == '-')
  {
    negate = 1;
    nptr++;
  }

  /*
   * Determine the base
   */
  if (*nptr != '0')
  {
    /* decimal string */
    base = 10;
    IB_LOG_INFO ("string is decimal", (uint32_t)base);
  }
  else
  {
    /* first 'real' character is a 0 */
    if (nptr[1] == 'X' || nptr[1] == 'x')
    {
      /* hexadecimal string */
      base = 16;
      nptr += 2;
      IB_LOG_INFO ("string is hexadecimal", (uint32_t)base);
    }
    else
    {
      /* decimal string */
      base = 10;
      IB_LOG_INFO ("string is decimal", (uint32_t)base);
    }
  }

  while ((digit = *nptr) != '\0')
  {
    if (digit >= '0' && digit < ('0' + base))
    {
      digit -= '0';
    }
    else
    {
      if (base > 10)
      {
        if (digit >= 'a' && digit < ('a' + (base - 10)))
        {
          digit = digit - 'a' + 10;
        }
        else if (digit >= 'A' && digit < ('A' + (base - 10)))
        {
          digit = digit - 'A' + 10;
        }
        else
        {
          IB_LOG_ERROR ("invalid digit:", (uint32_t)(int32_t)digit);
          IB_EXIT (function, (uint32_t)return_error);
          return return_error;
        }
      }
      else
      {
        IB_LOG_ERROR ("invalid digit:", (uint32_t)(int32_t)digit);
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }

    if (negate == 1)
    {
      digit = -digit;
      if ((cvalue > -922337203685477580ll) ||
          ((cvalue == -922337203685477580ll) && (digit >= -8)))
      {
        cvalue = cvalue * base;
        cvalue += digit;
      }
      else
      {
        IB_LOG_ERROR0 ("string value is too small");
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }
    else
    {
      if ((cvalue < 922337203685477580ll) ||
          ((cvalue == 922337203685477580ll) && (digit <= 7)))
      {
        cvalue = cvalue * base;
        cvalue += digit;
      }
      else
      {
        IB_LOG_ERROR0 ("string value is too large");
        IB_EXIT (function, (uint32_t)return_error);
        return return_error;
      }
    }
    nptr++;
  }

  IB_EXIT (function, (uint32_t)cvalue);
  return cvalue;
}

//==============================================================================//
//
// FUNCTION
//   cs_parse_gid
//
// DESCRIPTION
//   Converts an asci representation of a GID in hex of the format:
//     (0[xX])?[[:hex:]]{32}
//   into a Gid_t. Returns VSTATUS_OK upon success.
//
// INPUTS
//    str - the string to parse
//    gid - the gid in which to store the value
//
// OUTPUTS
//
//
// HISTORY
//
//    NAME	DATE  REMARKS
//
//==============================================================================//
Status_t
cs_parse_gid(const char * str, Gid_t gid)
{
	uint8_t * tmp = (uint8_t *) gid;
	int i = 0;
	const char * myPtr = NULL;
	char myNum[3];
	Status_t rc = VSTATUS_OK;

	IB_ENTER(__FUNCTION__, str, gid, 0, 0);

	if (  (str[0] == '0')
	   && ( (str[1] == 'x') || (str[1] == 'X') ) )
		myPtr = str + 2;
	else
		myPtr = str;

	if (strlen(myPtr) == 32)
	{
		for (i = 0; i < 16; ++i)
		{
			memcpy(myNum, myPtr + (i << 1), 2);
			myNum[2] = '\0';

			tmp[i] = strtoul(myNum, NULL, 16);
		}
	} else
	{
		rc = VSTATUS_ILLPARM;
	}

	IB_EXIT(__FUNCTION__, rc);
	return rc;
}

/**********************************************************************
*
* DESCRIPTION
*    Invokes snprintf to append the format string into the
*    passed buffer.  Will adjust the provided buffer pointer
*    to just beyond the concatenated portion, and decrement
*    len accordingly, such that a chain of invocations function
*    as appends.
*
* INPUTS
*    buf - Pointer to the output buffer.  Will be incremented by
*      the number of bytes written.
*    len - Pointer to the remaining length.  Will be decremented by
*      the number of bytes written.
*    fmt - printf-style format string.
*    ... - pritnf-style format string arguments.
*
* OUTPUTS
*    Returns the return value of printf.
*
**********************************************************************/
int cs_snprintfcat(char ** buf, size_t * len, char * fmt, ...)
{
	if (!buf || !len || !fmt || !*len)
		return 0;

	va_list(args);
	va_start(args, fmt);
	int n = vsnprintf(*buf, *len, fmt, args);
	va_end(args);

	if (n <= 0) return n;

	// printf returns number of bytes that *would* be written.
	// correct to actual bytes written
	size_t m = MIN((size_t)n, *len);

	*buf += m;
	*len -= m;

	return n;
}