BAL and Maple Release 2.2
Signed-off-by: Shad Ansari <developer@Carbon.local>
diff --git a/bal_release/src/lib/libutils/Makefile b/bal_release/src/lib/libutils/Makefile
new file mode 100644
index 0000000..8b4dd50
--- /dev/null
+++ b/bal_release/src/lib/libutils/Makefile
@@ -0,0 +1,35 @@
+###############################################################################
+#
+# <:copyright-BRCM:2016:DUAL/GPL:standard
+#
+# Copyright (c) 2016 Broadcom
+# All Rights Reserved
+#
+# Unless you and Broadcom execute a separate written software license
+# agreement governing use of this software, this software is licensed
+# to you under the terms of the GNU General Public License version 2
+# (the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+# with the following added to such license:
+#
+# As a special exception, the copyright holders of this software give
+# you permission to link this software with independent modules, and
+# to copy and distribute the resulting executable under terms of your
+# choice, provided that you also meet, for each linked independent
+# module, the terms and conditions of the license of that module.
+# An independent module is a module which is not derived from this
+# software. The special exception does not apply to any modifications
+# of the software.
+#
+# Not withstanding the above, under no circumstances may you combine
+# this software in any way with any other Broadcom software provided
+# under a license other than the GPL, without Broadcom's express prior
+# written consent.
+#
+# :>
+#
+###############################################################################
+MOD_NAME = balutils
+MOD_TYPE = lib
+
+srcs = bal_utils.c
+
diff --git a/bal_release/src/lib/libutils/bal_utils.c b/bal_release/src/lib/libutils/bal_utils.c
new file mode 100644
index 0000000..024b3d9
--- /dev/null
+++ b/bal_release/src/lib/libutils/bal_utils.c
@@ -0,0 +1,541 @@
+/******************************************************************************
+ *
+ * <:copyright-BRCM:2016:DUAL/GPL:standard
+ *
+ * Copyright (c) 2016 Broadcom
+ * All Rights Reserved
+ *
+ * Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed
+ * to you under the terms of the GNU General Public License version 2
+ * (the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+ * with the following added to such license:
+ *
+ * As a special exception, the copyright holders of this software give
+ * you permission to link this software with independent modules, and
+ * to copy and distribute the resulting executable under terms of your
+ * choice, provided that you also meet, for each linked independent
+ * module, the terms and conditions of the license of that module.
+ * An independent module is a module which is not derived from this
+ * software. The special exception does not apply to any modifications
+ * of the software.
+ *
+ * Not withstanding the above, under no circumstances may you combine
+ * this software in any way with any other Broadcom software provided
+ * under a license other than the GPL, without Broadcom's express prior
+ * written consent.
+ *
+ * :>
+ *
+ *****************************************************************************/
+
+/**
+ * @file bal_utils.c
+ * @brief BAL Utilities source
+ *
+ * This file contains the implementation of various BAL "utilities",
+ * which are provided via the libutils.a library.
+ */
+
+/*@{*/
+
+#ifdef USING_BAL_UTILS
+
+/* --- system includes ---*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <limits.h>
+#include <arpa/inet.h>
+#include <string.h>
+
+#include <bcmos_system.h>
+
+/* --- project includes ---*/
+#include "bal_utils.h"
+
+
+/*
+ * Generic helper functions
+ */
+char *mac_addr_to_str(char *buffer, bcmos_mac_address mac)
+{
+ char *fmt_str = NULL;
+
+ fmt_str = "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx";
+
+ snprintf(buffer, 20, fmt_str,
+ mac.u8[0], mac.u8[1],
+ mac.u8[2], mac.u8[3],
+ mac.u8[4], mac.u8[5]);
+
+ return buffer;
+}
+
+
+bcmos_bool mac_add_is_null(bcmos_mac_address mac)
+{
+ return ((0 != mac.u8[0]) || (0 != mac.u8[1]) || (0 != mac.u8[2]) ||
+ (0 != mac.u8[3]) || (0 != mac.u8[4]) || (0 != mac.u8[5])) ? BCMOS_FALSE : BCMOS_TRUE;
+}
+
+/**
+ * @brief Determines if string contains a valid IPv4 or IPv6 address
+ *
+ *
+ * @param ipAddrStr Pointer to string to parse
+ *
+ * @return bcmos_bool
+ * @retval TRUE String contains a valid IP address
+ * @retval FALSE String does not
+ */
+bcmos_bool BalIsValidIp(const char *ipAddrStr)
+{
+ struct sockaddr_in addr4;
+ struct in6_addr addr6;
+ bcmos_bool ret = BCMOS_FALSE;
+
+ /* Parameter checks. */
+ BUG_UNLESS(NULL != ipAddrStr, BCMOS_FALSE);
+
+ /* First look to see if it's a valid IPv4 address, then look to see if it's
+ a valid IPv6 address*/
+ if (inet_pton(AF_INET, ipAddrStr, &addr4) > 0 || inet_pton(AF_INET6, ipAddrStr, &addr6) > 0)
+ {
+ ret = TRUE;
+ }
+
+ return ret;
+}
+
+
+/**
+ * @brief Convert a string to the specified type of integer
+ *
+ * NOTE: This function uses the strtoll() function to convert the string to an
+ * integer value. U64 values greater than 0x7fffffffffffffff cannot be converted
+ * by the strtoll() function because the string value is considered out of the
+ * valid -0x8000000000000000 to 0x7fffffffffffffff 64-bit integer range.
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+static bcmos_errno BalStringToInt(char *str, BalIntStringT *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ U64 u64 = 0;
+ S64 s64 = 0;
+ char *endptr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+ BUG_UNLESS(pVal->intType > BAL_STR2INT_INVALID, BAL_PARAM);
+ BUG_UNLESS(pVal->intType < BAL_STR2INT_MAX, BAL_PARAM);
+
+ do
+ {
+ if ((pVal->intType >= BAL_STR2INT_S8) &&
+ (pVal->intType <= BAL_STR2INT_S64))
+ {
+ /* Just assume a signed 64-bit value when converting the string to
+ * an integer. Range checking is done below. Make sure that errno
+ * is set to zero before calling strtoll().
+ */
+ errno = 0;
+ pVal->intU.s64 = 0; /* Clear all possibilities to 0 */
+ s64 = strtoll(str, &endptr, 10);
+
+ /* General range and error check */
+ if ((errno == ERANGE && (s64 == LONG_MAX || s64 == LONG_MIN))
+ || (errno != 0 && s64 == 0))
+ {
+ errno = 0;
+ rc = BCM_ERR_RANGE;
+ break;
+
+ }
+
+ /* test for no digits or mixed digits and characters */
+ if (endptr == str || '\0' != *endptr)
+ {
+ errno = 0;
+ rc = BCM_ERR_PARM;
+ break;
+ }
+
+ /* routine specific range check */
+ switch (pVal->intType)
+ {
+ case BAL_STR2INT_S8:
+ if ((s64 < -128) || (s64 > 127))
+ {
+ rc = BCM_ERR_RANGE;
+ }
+ else
+ {
+ pVal->intU.s8 = (S8)s64;
+ }
+ break;
+ case BAL_STR2INT_S16:
+ if ((s64 < -32768) || (s64 > 32767))
+ {
+ rc = BCM_ERR_RANGE;
+ }
+ else
+ {
+ pVal->intU.s16 = (S16)s64;
+ }
+ break;
+ case BAL_STR2INT_S32:
+ if ((s64 < (-2147483647L -1L)) || (s64 > 2147483647L))
+ {
+ rc = BCM_ERR_RANGE;
+ }
+ else
+ {
+ pVal->intU.s32 = (S32)s64;
+ }
+ break;
+ case BAL_STR2INT_S64:
+ /* No range checking is needed since the strtoll() function
+ * does the range checking. If the string was invalid, errno
+ * would have been non-zero.
+ */
+ pVal->intU.s64 = s64;
+ break;
+ default:
+ /* Should never make it here. */
+ rc = BCM_ERR_PARM;
+ break;
+ }
+ }
+ else {
+ /* Just assume an unsigned 64-bit value when converting the string
+ * to an integer. Range checking is done below. Make sure that errno
+ * is set to zero before calling strtoull().
+ */
+ errno = 0;
+ pVal->intU.u64 = 0;
+ u64 = strtoull(str, &endptr, 10);
+
+ /* General range and error check */
+ if ((errno == ERANGE && (s64 == LONG_MAX || s64 == LONG_MIN))
+ || (errno != 0 && s64 == 0))
+ {
+ errno = 0;
+ rc = BCM_ERR_RANGE;
+ break;
+
+ }
+
+ /* test for no digits or mixed digits and characters */
+ if (endptr == str || '\0' != *endptr)
+ {
+ errno = 0;
+ rc = BCM_ERR_PARM;
+ break;
+ }
+
+ /* routine specific range check */
+ switch(pVal->intType)
+ {
+ case BAL_STR2INT_U8:
+ if (u64 > 255)
+ {
+ rc = BCM_ERR_RANGE;
+ }
+ else
+ {
+ pVal->intU.u8 = (U8)u64;
+ }
+ break;
+ case BAL_STR2INT_U16:
+ if (u64 > 65535)
+ {
+ rc = BCM_ERR_RANGE;
+ }
+ else
+ {
+ pVal->intU.u16 = (U16)u64;
+ }
+ break;
+ case BAL_STR2INT_U32:
+ if (u64 > 4294967295UL)
+ {
+ rc = BCM_ERR_RANGE;
+ }
+ else
+ {
+ pVal->intU.u32 = (U32)u64;
+ }
+ break;
+ case BAL_STR2INT_U64:
+ /* No range checking is needed since the strtoull() function
+ * does the range checking. If the string was invalid, errno
+ * would have been non-zero.
+ */
+ pVal->intU.u64 = u64;
+ break;
+ default:
+ /* Should never make it here. */
+ rc = BCM_ERR_PARM;
+ break;
+ }
+ }
+ } while (0);
+
+ return(rc);
+}
+
+/**
+ * @brief Convert a string to an S8 type integer
+ *
+ * This function converts a string to an S8 type integer
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+bcmos_errno BalStringToS8(char *str, S8 *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ BalIntStringT intStr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+
+ memset(&intStr, 0, sizeof(intStr));
+
+ intStr.intType = BAL_STR2INT_S8;
+
+ rc = BalStringToInt(str, &intStr);
+ if (BAL_OK == rc)
+ {
+ *pVal = intStr.intU.s8;
+ }
+
+ return(rc);
+}
+
+/**
+ * @brief Convert a string to an S16 type integer
+ *
+ * This function converts a string to an S16 type integer
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+bcmos_errno BalStringToS16(char *str, S16 *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ BalIntStringT intStr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+
+ memset(&intStr, 0, sizeof(intStr));
+
+ intStr.intType = BAL_STR2INT_S16;
+
+ rc = BalStringToInt(str, &intStr);
+ if (BAL_OK == rc)
+ {
+ *pVal = intStr.intU.s16;
+ }
+
+ return(rc);
+}
+
+/**
+ * @brief Convert a string to an S32 type integer
+ *
+ * This function converts a string to an S32 type integer
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+bcmos_errno BalStringToS32(char *str, S32 *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ BalIntStringT intStr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+
+ memset(&intStr, 0, sizeof(intStr));
+
+ intStr.intType = BAL_STR2INT_S32;
+
+ rc = BalStringToInt(str, &intStr);
+ if (BAL_OK == rc)
+ {
+ *pVal = intStr.intU.s32;
+ }
+
+ return(rc);
+}
+
+/**
+ * @brief Convert a string to an S64 type integer
+ *
+ * This function converts a string to an S64 type integer
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+bcmos_errno BalStringToS64(char *str, S64 *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ BalIntStringT intStr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+
+ memset(&intStr, 0, sizeof(intStr));
+
+ intStr.intType = BAL_STR2INT_S64;
+
+ rc = BalStringToInt(str, &intStr);
+ if (BAL_OK == rc)
+ {
+ *pVal = intStr.intU.s64;
+ }
+
+ return(rc);
+}
+
+/**
+ * @brief Convert a string to a U8 type integer
+ *
+ * This function converts a string to a U8 type integer
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+bcmos_errno BalStringToU8(char *str, U8 *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ BalIntStringT intStr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+
+ memset(&intStr, 0, sizeof(intStr));
+
+ intStr.intType = BAL_STR2INT_U8;
+
+ rc = BalStringToInt(str, &intStr);
+ if (BAL_OK == rc)
+ {
+ *pVal = intStr.intU.u8;
+ }
+
+ return(rc);
+}
+
+/**
+ * @brief Convert a string to a U16 type integer
+ *
+ * This function converts a string to a U16 type integer
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+bcmos_errno BalStringToU16(char *str, U16 *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ BalIntStringT intStr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+
+ memset(&intStr, 0, sizeof(intStr));
+
+ intStr.intType = BAL_STR2INT_U16;
+
+ rc = BalStringToInt(str, &intStr);
+ if (BAL_OK == rc)
+ {
+ *pVal = intStr.intU.u16;
+ }
+
+ return(rc);
+}
+
+/**
+ * @brief Convert a string to a U32 type integer
+ *
+ * This function converts a string to a U32 type integer
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+bcmos_errno BalStringToU32(char *str, U32 *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ BalIntStringT intStr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+
+ memset(&intStr, 0, sizeof(intStr));
+
+ intStr.intType = BAL_STR2INT_U32;
+
+ rc = BalStringToInt(str, &intStr);
+ if (BAL_OK == rc)
+ {
+ *pVal = intStr.intU.u32;
+ }
+
+ return(rc);
+}
+
+/**
+ * @brief Convert a string to a U64 type integer
+ *
+ * This function converts a string to a U64 type integer
+ *
+ * @param str String to convert
+ * @param pVal Pointer to the return value
+ *
+ * @return bcmos_errno
+ */
+bcmos_errno BalStringToU64(char *str, U64 *pVal)
+{
+ bcmos_errno rc = BAL_OK;
+ BalIntStringT intStr;
+
+ BUG_UNLESS(NULL != str, BAL_PARAM);
+ BUG_UNLESS(NULL != pVal, BAL_PARAM);
+
+ memset(&intStr, 0, sizeof(intStr));
+
+ intStr.intType = BAL_STR2INT_U64;
+
+ rc = BalStringToInt(str, &intStr);
+ if (BAL_OK == rc)
+ {
+ *pVal = intStr.intU.u64;
+ }
+
+ return(rc);
+}
+
+
+#endif /* USING_BAL_UTILS */
diff --git a/bal_release/src/lib/libutils/bal_utils.h b/bal_release/src/lib/libutils/bal_utils.h
new file mode 100644
index 0000000..78c6134
--- /dev/null
+++ b/bal_release/src/lib/libutils/bal_utils.h
@@ -0,0 +1,65 @@
+/******************************************************************************
+ *
+ * <:copyright-BRCM:2016:DUAL/GPL:standard
+ *
+ * Copyright (c) 2016 Broadcom
+ * All Rights Reserved
+ *
+ * Unless you and Broadcom execute a separate written software license
+ * agreement governing use of this software, this software is licensed
+ * to you under the terms of the GNU General Public License version 2
+ * (the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+ * with the following added to such license:
+ *
+ * As a special exception, the copyright holders of this software give
+ * you permission to link this software with independent modules, and
+ * to copy and distribute the resulting executable under terms of your
+ * choice, provided that you also meet, for each linked independent
+ * module, the terms and conditions of the license of that module.
+ * An independent module is a module which is not derived from this
+ * software. The special exception does not apply to any modifications
+ * of the software.
+ *
+ * Not withstanding the above, under no circumstances may you combine
+ * this software in any way with any other Broadcom software provided
+ * under a license other than the GPL, without Broadcom's express prior
+ * written consent.
+ *
+ * :>
+ *
+ *****************************************************************************/
+
+/**
+ * @file bal_utils.h
+ * @brief BAL Utilities include file
+ *
+ */
+
+#ifndef BALUTILS_H
+#define BALUTILS_H
+
+/*@{*/
+
+/**
+ * @brief General purpose BAL String structure.
+ *
+ * This is typically used for debugging or log messages.
+ */
+#define BAL_STRING_LENGTH 256
+
+#define MAC_STR_LEN 18
+
+/**
+ * @brief BAL String Structure
+ */
+typedef struct bal_string
+{
+ char str[BAL_STRING_LENGTH+1]; /**< The string */
+} bal_string;
+
+extern char *mac_addr_to_str(char *buffer, bcmos_mac_address mac);
+extern bcmos_bool mac_add_is_null(bcmos_mac_address mac);
+
+/*@}*/
+
+#endif /* BALUTILS_H */