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 */