/* BEGIN_ICS_COPYRIGHT6 ****************************************

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

#if !defined(VXWORKS)

#define _GNU_SOURCE

#endif

#include "imemory.h"

#include "idebug.h"

#include "itimer.h"

#include <stdarg.h>

#include <errno.h>

#include <stdlib.h>

#include <unistd.h>

#include <ctype.h>

#define MAX_VFABRIC_NAME	64	// from fm_xml.h

// from stl_pa.h

#define STL_PA_SELECT_UTIL_HIGH			0x00020001

#define STL_PA_SELECT_UTIL_MC_HIGH		0x00020081

#define STL_PA_SELECT_UTIL_PKTS_HIGH		0x00020082

#define STL_PA_SELECT_CATEGORY_INTEG			0x00030001

#define STL_PA_SELECT_CATEGORY_CONG			0x00030002

#define STL_PA_SELECT_CATEGORY_SMA_CONG		0x00030003

#define STL_PA_SELECT_CATEGORY_BUBBLE		0x00030004

#define STL_PA_SELECT_CATEGORY_SEC			0x00030005

#define STL_PA_SELECT_CATEGORY_ROUT			0x00030006

#define FOCUS_PORTS_COMPARATOR_INVALID			0

#define FOCUS_PORTS_COMPARATOR_GREATER_THAN		1

#define FOCUS_PORTS_COMPARATOR_LESS_THAN		2

#define FOCUS_PORTS_COMPARATOR_GREATER_THAN_OR_EQUAL	3

#define FOCUS_PORTS_COMPARATOR_LESS_THAN_OR_EQUAL	4

#if defined(MEM_TRACK_ON)

#if defined(VXWORKS)

#include "tickLib.h"

#define TICK tickGet()

#else

#define TICK 0 // TBD need to specify value for Linux and MAC

#endif

#define MEM_TRACK_FTR

#include "imemtrack.h"

// Default number of headers to allocate at a time.

#define MEM_HDR_ALLOC_SIZE	50

#if defined(MEM_TRACK_ON)

#define UNTRACKED_COUNT 12000

void *unTAddr[UNTRACKED_COUNT];

int unTindex=0;

int unTmissed=0;

#endif

MEM_TRACKER	*pMemTracker = NULL;

static uint32 last_reported_allocations;

static uint32 total_allocations;

static uint32 last_reported_secs;

static uint32 current_allocations;

static uint32 current_allocated;

static uint32 max_allocations;

static uint32 max_allocated;

static void MemoryTrackerDereference(MemoryTrackerFileName_t *trk);

static MemoryTrackerFileName_t *MemoryTrackerBuckets[MEMORY_TRACKER_BUCKETS];

#endif	// MEM_TRACK_ON

#ifdef VXWORKS

extern unsigned long long strtoull (const char *__s, char **__endptr, int __base);

extern long long strtoll (const char *__s, char **__endptr, int __base);

#endif

char*

StringConcat(const char* str1, ...)

{

#ifdef VXWORKS

#define stpcpy(s1, s2) (strcpy(s1, s2) + strlen(s2))

#endif

	if (!str1)

		return NULL;

	/* calculate length first */

	size_t strings_length = 1 + strlen(str1);

	va_list args;

	va_start(args, str1);

	char* str = va_arg(args, char*);

	while (str) {

		strings_length += strlen(str);

		str = va_arg(args, char*);

	}

	va_end(args);

	/* next, allocate a memory */

	char* string = (char*)malloc(strings_length);

	if (!string)

		return NULL;

	/* finally, create the string */

	char* string_tmp = stpcpy(string, str1);

	va_start(args, str1);

	str = va_arg(args, char*);

	while (str) {

		string_tmp = stpcpy(string_tmp, str);

		str = va_arg(args, char*);

	}

	va_end(args);

	return string;

}

// convert a string to a uint64.  Very similar to strtoull except that

// base=0 implies base 10 or 16, but excludes base 8

// hence allowing leading 0's for base 10.

//

// Also provides easier to use status returns and error checking.

//

// Can also optionally skip trailing whitespace, when skip_trail_whietspace is

// FALSE, trailing whitespace is treated as a FERROR

//

// When endptr is NULL, trailing characters (after optional whitespace) are 

// considered an FERROR.  When endptr is non-NULL, for a FSUCCESS conversion,

// it points to the characters after the optional trailing whitespace.

// Errors:

//	FSUCCESS - successful conversion, *endptr points to 1st char after value

//	FERROR - invalid contents, non-numeric

//	FINVALID_SETTING - value out of range

//	FINVALID_PARAMETER - invalid function arguments (NULL value or str)

FSTATUS StringToUint64(uint64 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	char *end = NULL;

	uint64 temp;

	if (! str || ! value)

		return FINVALID_PARAMETER;

	errno = 0;

	temp = strtoull(str, &end, base?base:10);

	if ( ! base && ! (temp == IB_UINT64_MAX && errno)

		&& (end && temp == 0 && *end == 'x' && end != str)) {

		// try again as base 16

		temp = strtoull(str, &end, 16);

	}

	if ((temp == IB_UINT64_MAX && errno)

		|| (end && end == str)) {

		if (errno == ERANGE)

			return FINVALID_SETTING;

		else

			return FERROR;

	}

	// skip whitespace

	if (end && skip_trail_whitespace) {

		while (isspace(*end)) {

			end++;

		}

	}

	if (endptr)

		*endptr = end;

	else if (end && *end != '\0')

		return FERROR;

	*value = temp;

	return FSUCCESS;

}

FSTATUS StringToUint32(uint32 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	uint64 temp;

	FSTATUS status;

	status = StringToUint64(&temp, str, endptr, base, skip_trail_whitespace);

	if (status != FSUCCESS)

		return status;

	if (temp > IB_UINT32_MAX)

		return FINVALID_SETTING;

	*value = (uint32)temp;

	return FSUCCESS;

}

FSTATUS StringToUint16(uint16 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	uint64 temp;

	FSTATUS status;

	status = StringToUint64(&temp, str, endptr, base, skip_trail_whitespace);

	if (status != FSUCCESS)

		return status;

	if (temp > IB_UINT16_MAX)

		return FINVALID_SETTING;

	*value = (uint16)temp;

	return FSUCCESS;

}

FSTATUS StringToUint8(uint8 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	uint64 temp;

	FSTATUS status;

	status = StringToUint64(&temp, str, endptr, base, skip_trail_whitespace);

	if (status != FSUCCESS)

		return status;

	if (temp > IB_UINT8_MAX)

		return FINVALID_SETTING;

	*value = (uint8)temp;

	return FSUCCESS;

}

// convert a string to a int64.  Very similar to strtoull except that

// base=0 implies base 10 or 16, but excludes base 8

// hence allowing leading 0's for base 10.

//

// Also provides easier to use status returns and error checking.

//

// Can also optionally skip trailing whitespace, when skip_trail_whitespace is

// FALSE, trailing whitespace is treated as a FERROR

//

// When endptr is NULL, trailing characters (after optional whitespace) are 

// considered an FERROR.  When endptr is non-NULL, for a FSUCCESS conversion,

// it points to the characters after the optional trailing whitespace.

// Errors:

//	FSUCCESS - successful conversion, *endptr points to 1st char after value

//	FERROR - invalid contents, non-numeric

//	FINVALID_SETTING - value out of range

//	FINVALID_PARAMETER - invalid function arguments (NULL value or str)

FSTATUS StringToInt64(int64 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	char *end = NULL;

	int64 temp;

	if (! str || ! value)

		return FINVALID_PARAMETER;

	errno = 0;

	temp = strtoll(str, &end, base?base:10);

	if ( ! base && ! ((temp == IB_INT64_MAX || temp == IB_INT64_MIN) && errno)

		&& (end && temp == 0 && *end == 'x' && end != str)) {

		// try again as base 16

		temp = strtoll(str, &end, 16);

	}

	if (((temp == IB_INT64_MAX || temp == IB_INT64_MIN) && errno)

		|| (end && end == str)) {

		if (errno == ERANGE)

			return FINVALID_SETTING;

		else

			return FERROR;

	}

	// skip whitespace

	if (end && skip_trail_whitespace) {

		while (isspace(*end)) {

			end++;

		}

	}

	if (endptr)

		*endptr = end;

	else if (end && *end != '\0')

		return FERROR;

	*value = temp;

	return FSUCCESS;

}

FSTATUS StringToInt32(int32 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	int64 temp;

	FSTATUS status;

	status = StringToInt64(&temp, str, endptr, base, skip_trail_whitespace);

	if (status != FSUCCESS)

		return status;

	if (temp < IB_INT32_MIN || temp > IB_INT32_MAX)

		return FINVALID_SETTING;

	*value = (int32)temp;

	return FSUCCESS;

}

FSTATUS StringToInt16(int16 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	int64 temp;

	FSTATUS status;

	status = StringToInt64(&temp, str, endptr, base, skip_trail_whitespace);

	if (status != FSUCCESS)

		return status;

	if (temp < IB_INT16_MIN || temp > IB_INT16_MAX)

		return FINVALID_SETTING;

	*value = (int16)temp;

	return FSUCCESS;

}

FSTATUS StringToInt8(int8 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	int64 temp;

	FSTATUS status;

	status = StringToInt64(&temp, str, endptr, base, skip_trail_whitespace);

	if (status != FSUCCESS)

		return status;

	if (temp < IB_INT8_MIN || temp > IB_INT8_MAX)

		return FINVALID_SETTING;

	*value = (int8)temp;

	return FSUCCESS;

}

// GID of form hValue:lValue

// values must be base 16, as such 0x prefix is optional for both hValue and

// lValue

// whitespace is permitted before and after :

FSTATUS StringToGid(uint64 *hValue, uint64 *lValue, const char* str, char **endptr, boolean skip_trail_whitespace)

{

	FSTATUS status;

	char *end;

	status = StringToUint64(hValue, str, &end, 16, TRUE);

	if (status != FSUCCESS)

		return status;

	if (end == NULL  || *end != ':')

		return FERROR;

	end++;

	return StringToUint64(lValue, end, endptr, 16, skip_trail_whitespace);

}

// VESWPort of form guid:port:index or desc:port:index

// guid must be base 16, as such 0x prefix is optional.

// desc max size is MAX_VFABRIC_NAME (64)

// port and index are decimal

// whitespace is permitted before and after :

// byname = 0: the format is guid:port:index

// byname = 1: the format is desc:port:index

FSTATUS StringToVeswPort(uint64 *guid, char *desc, uint32 *port, uint32 *index,

	const char* str, char **endptr, boolean skip_trail_whitespace,

	boolean byname)

{

	FSTATUS status = FSUCCESS;

	char *end, *string = NULL;

	char *name;

	if (byname) {

		string = strdup(str);

		name = strtok_r((char *)string, ":", &end;;

		if (name != NULL && strlen(name) <= MAX_VFABRIC_NAME && end != NULL) {

			strcpy(desc, name);

		} else {

			status = FERROR;

			goto out;

		}

	} else {

		status = StringToUint64(guid, str, &end, 16, TRUE);

		if (status != FSUCCESS || end == NULL || *end != ':') {

			status = FERROR;

			goto out;

		}

		end++;

	}

	status = StringToUint32(port, end, &end, 10, TRUE);

	if (status != FSUCCESS || end == NULL || *end != ':') {

		status = FERROR;

		goto out;

	}

	end++;

	status = StringToUint32(index, end, endptr, 10, skip_trail_whitespace);

out:

	if (string != NULL) {

		free(string);

	}

	return status;

}

// MAC Address of form %02x:%02x:%02x:%02x:%02x:%02x

// values must be base16, 0x prefix is optional

FSTATUS StringToMAC(uint8_t *MAC,const char *str, char **endptr,

					boolean skip_trail_whitespace)

{

	FSTATUS status;

	char *end = NULL;

	status = StringToUint8(&MAC[0], str, &end, 16, FALSE);

	if (status != FSUCCESS)

		return status;

	if ((end == NULL) || (*end != ':'))

		return FERROR;

	end++;

	status = StringToUint8(&MAC[1], end, &end, 16, FALSE);

	if (status != FSUCCESS)

		return status;

	if ((end == NULL) || (*end != ':'))

		return FERROR;

	end++;

	status = StringToUint8(&MAC[2], end, &end, 16, FALSE);

	if (status != FSUCCESS)

		return status;

	if ((end == NULL) || (*end != ':'))

		return FERROR;

	end++;

	status = StringToUint8(&MAC[3], end, &end, 16, FALSE);

	if (status != FSUCCESS)

		return status;

	if ((end == NULL) || (*end != ':'))

		return FERROR;

	end++;

	status = StringToUint8(&MAC[4], end, &end, 16, FALSE);

	if (status != FSUCCESS)

		return status;

	if ((end == NULL) || (*end != ':'))

		return FERROR;

	end++;

	status = StringToUint8(&MAC[5], end, endptr, 16, FALSE);

	return status;

}

// Byte Count as an integer followed by an optional suffix of:

// K, KB, M, MB, G or GB

// (K==KB, etc)

// converted to an absolute number of bytes

FSTATUS StringToUint64Bytes(uint64 *value, const char* str, char **endptr, int base, boolean skip_trail_whitespace)

{

	char *end;

	FSTATUS status;

	uint64 temp;

	status = StringToUint64(&temp, str, &end, base, skip_trail_whitespace);

	if (status != FSUCCESS)

		return status;

	if (end) {

		char *units = end;

		// skip whitespace

		while (isspace(*units)) {

			units++;

		}

		// parse optional units

		if (strncmp(units, "KB",2) == 0) {

			temp *= 1024;

			end = units+2;

		} else if (strncmp(units, "K",1) == 0) {

			temp *= 1024;

			end = units+1;

		} else if (strncmp(units, "MB",2) == 0) {

			temp *= 1024*1024;

			end = units+2;

		} else if (strncmp(units, "M",1) == 0) {

			temp *= 1024*1024;

			end = units+1;

		} else if (strncmp(units, "GB",2) == 0) {

			temp *= (1024*1024*1024ULL);

			end = units+2;

		} else if (strncmp(units, "G",1) == 0) {

			temp *= (1024*1024*1024ULL);

			end = units+1;

		}

	}

	// skip whitespace

	if (end && skip_trail_whitespace) {

		while (isspace(*end)) {

			end++;

		}

	}

	if (endptr)

		*endptr = end;

	else if (end && *end != '\0')

		return FERROR;

	*value = temp;

	return FSUCCESS;

}

#if !defined(VXWORKS)

#define RELATIVE_TIME_STR_LEN 3

                                                     // June 6th, 2015 11:59:59 PM

													 // as represented by the format

static const char * date_formats[] = {"%Y-%m-%d %T", // 2015-06-30 23:59:59

                                      "%Y-%m-%d %R", // 2015-06-30 23:59

                                      "%Y-%m-%d",    // 2015-06-30

                                      "%m/%d/%Y %T", // 06/30/2015 23:59:59

                                      "%m/%d/%Y %R", // 06/30/2015 23:59

                                      "%m/%d/%Y",    // 06/30/2015

                                      "%d.%m.%Y %T", // 30.06.2015 23:59:59

                                      "%d.%m.%Y %R", // 30.06.2015 23:59

                                      "%d.%m.%Y",    // 30.06.2015

                                                     // %x, %X are locale specific

                                      "%x %X",       // e.g. 30/06/15 23:59:59 or 30.06.2015 23.59.59, etc.

                                      "%x",          // e.g. 30/06/15, 06/30/15, etc.

                                      "%X",          // e.g. 23:59:59, 23.59.59, etc.

                                      "%R"};         // 23:59

static const char * time_units[] = {"seconds", "minutes", "hours", "days"};

/**

 * StringToDateTime - parse a string to return a date/time

 *

 * @param value  - will contain date as # of seconds since epoch if parsing successful

 * @param str    - the string representation of the date to be parsed

 *

 * @return - FSTATUS indicating success or failure of parsing:

 * 			 FSUCCESS - successful parsing

 * 			 FINVALID_PARAMETER - str not valid date/time or not in valid format

 * 			 FINVALID_SETTING - relative value out of range

 * 			 FINSUFFICIENT_MEMORY - memory could not be allocated to parse string

 * 			 FERROR - other error parsing string

 */

FSTATUS StringToDateTime(uint32 *value, const char* str){

	int i, len;

	char * return_str;

	struct tm tm = {0};

	uint32 seconds;

	FSTATUS status;

	//try to match input to one of known formats from above

	len = sizeof(date_formats) / sizeof(const char *);

	for (i = 0; i < len; ++i){

		memset(&tm, 0, sizeof(struct tm));

		return_str = strptime(str, date_formats[i], &tm;;

		// want to match an exact format, meaning strptime returns null byte

		if (return_str != NULL && *return_str == '\0'){

			break;

		}

	}

	if (return_str != NULL && *return_str== '\0'){ // possible valid date entered

		struct tm tm2;

		time_t timer;

		if (i >= len - 2){

			// strptime matched against %X or %R, meaning we have a time

			// but no information on the date. Fill in tm with today's date

			time(&timer;;   //get current time

			struct tm * tmp;

			tmp = localtime(&timer;;

			if (!tmp){

				return FERROR;

			}

			tm.tm_year = tmp->tm_year;

			tm.tm_mon = tmp->tm_mon;

			tm.tm_mday = tmp->tm_mday;

			tm.tm_wday = tmp->tm_wday;

			tm.tm_yday = tmp->tm_yday;

		}

		// mktime will normalize fields of tm if they are outside their valid range,

		// so make a copy before the mktime call and compare before and after. If the

		// days of the month are not equal then the date enetered was not valid

		memcpy(&tm2, &tm, sizeof(struct tm));

		tm.tm_isdst = -1; //signal mktime to determine if daylight saving in effect

		timer = mktime(&tm;;

		if (timer != -1){

			//check if input time was a valid date, e.g. not 02/30/YYYY

			if (tm.tm_mday != tm2.tm_mday){

				return FINVALID_PARAMETER;

			}else{

				*value = (uint32) timer;

				return FSUCCESS;

			}

		}

	}else{

		// determine if time entered in the form

		// "<x> <units> ago" where units is a member of time_units from above

		char *string, *saveptr, *token, *tokens[RELATIVE_TIME_STR_LEN];

		string = strdup(str);

		if (!string){

			return FINSUFFICIENT_MEMORY;

		}

		//split string by space (" ")

		token = strtok_r(string, " ", &saveptr);

		i = 0;

		while (token != NULL){

			if (i >= RELATIVE_TIME_STR_LEN){

				//too many tokens

				free(string);

				return FERROR;

			}

			tokens[i] = token;

			++i;

			token = strtok_r(NULL, " ", &saveptr);

		}

		//check if proper number of tokens

		if (i != RELATIVE_TIME_STR_LEN){

			free(string);

			return FINVALID_PARAMETER;

		}

		//check if first token is a valid base 10 number

		status = StringToUint32(&seconds, tokens[0], NULL, 10, TRUE);

		if (FSUCCESS != status){

			free(string);

			return status;

		}

		//check if second token in accepted units of time

		len = sizeof(time_units) / sizeof (const char *);

		for (i = 0; i < len; ++i){

			if (strcasecmp(time_units[i], tokens[1]) == 0 || strncasecmp(time_units[i], tokens[1], strlen(time_units[i]) - 1) == 0){

				break;

			}

		}

		//convert first token to seconds if necessary

		if (i >= len){

			// could not determine units

			free(string);

			return FERROR;

		}

		switch (i){

		case 0:

			break;

		case 1: //convert from minutes to seconds

			seconds = seconds * 60;

			break;

		case 2: //convert from hours to seconds

			seconds = seconds * 60 * 60;

			break;

		case 3: //convert from days to seconds

			seconds = seconds * 24 * 60 * 60;

		}

		//calculate absolute time to query for

		time_t timer;

		time(&timer;;

		*value = (uint32)timer - seconds;

		free(string);

		return FSUCCESS;

	}

	return FERROR;

}

// Tuple of form select:comparator:argument

// select must be one of "utilization", "pktrate", "integrity", "congestion", "smacongestion", "bubbles", "security", or "routing".

// comparator must be one of "GT", "LT", "GE", "LE".

// argument may be any 64-bit value

// string inputs are case insensitive.

FSTATUS StringToTuple(uint32 *select, uint8 *comparator, uint64 *argument, char* str, char **endptr)

{

	FSTATUS status = FSUCCESS;

	char *end;

	char *selectstr;

	char *comparatorstr;

	char *argumentstr;

	if ((select == NULL) || (comparator == NULL) || (argument == NULL) || (str == NULL))

		return FERROR;

	selectstr = strtok_r(str, ":", &end;;

	if (selectstr == NULL)

		return FERROR;

	if (strcasecmp(selectstr, "utilization") == 0)

		*select = STL_PA_SELECT_UTIL_HIGH;

	else if (strcasecmp(selectstr, "pktrate") == 0)

		*select = STL_PA_SELECT_UTIL_PKTS_HIGH;

	else if (strcasecmp(selectstr, "integrity") == 0)

		*select = STL_PA_SELECT_CATEGORY_INTEG;

	else if (strcasecmp(selectstr, "congestion") == 0)

		*select = STL_PA_SELECT_CATEGORY_CONG;

	else if (strcasecmp(selectstr, "smacongestion") == 0)

		*select = STL_PA_SELECT_CATEGORY_SMA_CONG;

	else if (strcasecmp(selectstr, "bubbles") == 0)

		*select = STL_PA_SELECT_CATEGORY_BUBBLE;

	else if (strcasecmp(selectstr, "security") == 0)

		*select = STL_PA_SELECT_CATEGORY_SEC;

	else if (strcasecmp(selectstr, "routing") == 0)

		*select = STL_PA_SELECT_CATEGORY_ROUT;

	else

		return FERROR;

	comparatorstr = strtok_r((char *)NULL, ":", &end;;

	if (comparatorstr == NULL)

		return FERROR;

	if (strcasecmp(comparatorstr, "GT") == 0)

		*comparator = FOCUS_PORTS_COMPARATOR_GREATER_THAN;

	else if (strcasecmp(comparatorstr, "LT") == 0)

		*comparator = FOCUS_PORTS_COMPARATOR_LESS_THAN;

	else if (strcasecmp(comparatorstr, "GE") == 0)

		*comparator = FOCUS_PORTS_COMPARATOR_GREATER_THAN_OR_EQUAL;

	else if (strcasecmp(comparatorstr, "LE") == 0)

		*comparator = FOCUS_PORTS_COMPARATOR_LESS_THAN_OR_EQUAL;

	else

		return FERROR;

	argumentstr = strtok_r((char *)NULL, ":", &end;;

	if (argumentstr) {

		status = StringToUint64(argument, argumentstr, NULL, 0, TRUE);

		return status;

	}

	return FERROR;

}

#endif

#if !defined(VXWORKS)

#define MEMORY_ALLOCATE_PRIV(size, flags, tag) MemoryAllocatePriv(size, flags, tag)

#define MEMORY_ALLOCATE_PHYS_CONT_PRIV(size) MemoryAllocatePhysContPriv(size)

#define MEMORY_DEALLOCATE_PHYS_CONT_PRIV(size) MemoryDeallocatePhysContPriv(size)

#define MEMORY_DEALLOCATE_PRIV(ptr) MemoryDeallocatePriv(ptr)

#else

#define MEMORY_ALLOCATE_PRIV(size, flags, tag) MemoryAllocatePriv(size, __builtin_return_address(0))

#define MEMORY_ALLOCATE_PHYS_CONT_PRIV(size) MemoryAllocatePhysContPriv(size, __builtin_return_address(0))

#define MEMORY_DEALLOCATE_PHYS_CONT_PRIV(size) MemoryDeallocatePhysContPriv(size, __builtin_return_address(0))

#define MEMORY_DEALLOCATE_PRIV(ptr) MemoryDeallocatePriv(ptr, __builtin_return_address(0))

#endif

#if defined(MEM_TRACK_ON)

//

// Destroy the memory tracker object.

//

static __inline void

DestroyMemTracker( void )

{

	MEM_TRACKER *tmp;

	if( !pMemTracker )

		return;

	tmp = pMemTracker;

	pMemTracker = NULL; /* so no one uses it while we're destroying it */

	// Destory all objects in the memory tracker object.

	QListDestroy( &tmp->FreeHrdList );

	SpinLockDestroy( &tmp->Lock );

	QListDestroy( &tmp->AllocList );

	// Free the memory allocated for the memory tracker object.

	MEMORY_DEALLOCATE_PRIV( tmp );

}

//

// Allocate and initialize the memory tracker object.

//

static __inline boolean

CreateMemTracker( void )

{

	MEM_TRACKER *tmp;

	if( pMemTracker )

		return TRUE;

	// Allocate the memory tracker object. Don't update global until we're done

	tmp = (MEM_TRACKER*)MEMORY_ALLOCATE_PRIV( sizeof(MEM_TRACKER), IBA_MEM_FLAG_LEGACY, TRK_TAG );

	if( !tmp )

		return FALSE;

	// Pre-initialize all objects in the memory tracker object.

	QListInitState( &tmp->AllocList );

	SpinLockInitState( &tmp->Lock );

	QListInitState( &tmp->FreeHrdList );

	// Initialize the list.

	if( !QListInit( &tmp->AllocList ) )

	{

		/* global isn't initialize, don't call Destroy func; do the clean up */

		MEMORY_DEALLOCATE_PRIV( tmp );

		return FALSE;

	}

	// Initialize the spin lock to protect list operations.

	if( !SpinLockInit( &tmp->Lock ) )

	{

		/* global isn't initialize, don't call Destroy func; do the clean up */

		QListDestroy( &tmp->AllocList );

		SpinLockDestroy( &tmp->Lock );

		MEMORY_DEALLOCATE_PRIV( tmp );

		return FALSE;

	}

	// Initialize the free list.

	if( !QListInit( &tmp->FreeHrdList ) )

	{

		/* global isn't initialize, don't call Destroy func; do the clean up */

		QListDestroy( &tmp->AllocList );

		SpinLockDestroy( &tmp->Lock );

		MEMORY_DEALLOCATE_PRIV( tmp );

		return FALSE;

	}

//	MsgOut( "\n\n\n*** Memory tracker object address = %p ***\n\n\n", tmp );

	MsgOut( "\n*** Memory tracker enabled ***\n" );

	/* NOW update the global */

	pMemTracker = tmp;

	return TRUE;

}

#endif

//

// Enables memory allocation tracking.

//

static __inline void

MemoryTrackStart( void )

{

#if defined(MEM_TRACK_ON)

	if( pMemTracker )

		return;

	CreateMemTracker();

#endif	// MEM_TRACK_ON

}

//

// Clean up memory tracking.

//

static __inline void

MemoryTrackStop( void )

{

#if defined(MEM_TRACK_ON)

	LIST_ITEM	*pListItem;

	if( !pMemTracker )

		return;

	if( QListCount( &pMemTracker->AllocList ) )

	{

		// There are still items in the list.  Print them out.

		MemoryDisplayUsage(1, 0, 0);

	} else {

		MsgOut( "\n*** Memory tracker stopped, no leaks detected ***\n" );

		MsgOut("IbAccess max allocations=%u bytes=%u\n",

						max_allocations, max_allocated);

	}

	// Free all allocated headers.

	SpinLockAcquire( &pMemTracker->Lock );

	while( (pListItem = QListRemoveHead( &pMemTracker->AllocList )) != NULL )

	{

		SpinLockRelease( &pMemTracker->Lock );

		MEMORY_DEALLOCATE_PRIV( PARENT_STRUCT( pListItem, MEM_ALLOC_HDR, ListItem ) );

		SpinLockAcquire( &pMemTracker->Lock );

	}

	while( (pListItem = QListRemoveHead( &pMemTracker->FreeHrdList )) != NULL )

	{

		SpinLockRelease( &pMemTracker->Lock );

		MEMORY_DEALLOCATE_PRIV( PARENT_STRUCT( pListItem, MEM_ALLOC_HDR, ListItem ) );

		SpinLockAcquire( &pMemTracker->Lock );

	}

	SpinLockRelease( &pMemTracker->Lock );

	DestroyMemTracker();

#endif	// MEM_TRACK_ON

}