BOOL convertAsciiToHexInPlace( INT8 *p_string, UINT8 expectedHexBinSize )
{
INT8 ascii_buffer[3];
UINT8 hex_binary_index = 0;
INT8 *hex_string_start = p_string;
UINT16 hex_buffer = 0;
/* gobble up any hex prefix */
if ( memcmppgm2ram (hex_string_start, (const ROM FAR char*) "0x", 2) == 0 )
hex_string_start+=2;
if ( strlen( (char *) hex_string_start) != (expectedHexBinSize*2) )
return FALSE;
while ( hex_binary_index < expectedHexBinSize )
{
memcpy ( ascii_buffer, (const char*) hex_string_start, 2 );
ascii_buffer[2] = '\0';
/* convert the hex string to a machine hex value */
if ( !ConvertASCIIHexToBinary( ascii_buffer,&hex_buffer) )
return FALSE;
p_string[hex_binary_index++] = (UINT8) hex_buffer;
hex_string_start +=2;
}
return TRUE;
}
tZGBool convertAsciiToHexInPlace( tZGS8 *p_string, tZGU8 expectedHexBinSize )
{
tZGS8 ascii_buffer[3];
tZGU8 hex_binary_index = 0;
tZGS8 *hex_string_start = p_string;
tZGU16 hex_buffer = 0;
/* gobble up any hex prefix */
if ( memcmppgm2ram (hex_string_start, (const ROM FAR char*) "0x", 2) == 0 )
hex_string_start+=2;
if ( strlen( (char *) hex_string_start) != (expectedHexBinSize*2) )
return kZGBoolFalse;
while ( hex_binary_index < expectedHexBinSize )
{
memcpy ( ascii_buffer, (const char*) hex_string_start, 2 );
ascii_buffer[2] = '\0';
/* convert the hex string to a machine hex value */
if ( !ConvertASCIIHexToBinary( ascii_buffer,&hex_buffer) )
return kZGBoolFalse;
p_string[hex_binary_index++] = (tZGU8) hex_buffer;
hex_string_start +=2;
}
return kZGBoolTrue;
}
bool convertAsciiToHexInPlace( int8_t *p_string, uint8_t expectedHexBinSize )
{
int8_t ascii_buffer[3];
uint8_t hex_binary_index = 0;
int8_t *hex_string_start = p_string;
uint16_t hex_buffer = 0;
/* gobble up any hex prefix */
if ( memcmp (hex_string_start, (const const FAR char*) "0x", 2) == 0 )
hex_string_start+=2;
if ( strlen( (char *) hex_string_start) != (expectedHexBinSize*2) )
return false;
while ( hex_binary_index < expectedHexBinSize )
{
memcpy ( ascii_buffer, (const char*) hex_string_start, 2 );
ascii_buffer[2] = '\0';
/* convert the hex string to a machine hex value */
if ( !ConvertASCIIHexToBinary( ascii_buffer,&hex_buffer) )
return false;
p_string[hex_binary_index++] = (uint8_t) hex_buffer;
hex_string_start +=2;
}
return true;
}
/*****************************************************************************
* FUNCTION: isMacAddress
*
* RETURNS: True if valid MAC address, else False
*
* PARAMS: p_string -- string to check
* p_Address -- Array where MAC values will be written
*
* NOTES: Determines if the input string is a valid MAC address.
* If it is, then returns an array of 6 bytes for each of the values.
* MAC address must be in hex in the format xx:xx:xx:xx:xx:xx
*****************************************************************************/
static tZGBool isMacAddress(tZGS8 *p_string, tZGU8 *p_Address)
{
tZGU8 i;
tZGU16 tmp;
if (strlen((char *)p_string) != 17u)
{
return kZGBoolFalse;
}
// ensure the ':' is in the right place, and if so, set them to 0
for (i = 2; i < 17u; i += 3)
{
if (p_string[i] == (tZGS8)':')
{
p_string[i] = '\0';
}
else
{
return kZGBoolFalse;
}
}
// now extract each hex number string
for (i = 0; i < 6u; ++i)
{
if (!ConvertASCIIHexToBinary(&p_string[i * 3], &tmp))
{
return kZGBoolFalse;
}
p_Address[i] = (tZGU8) (tmp & 0xFF);
}
return kZGBoolTrue;
}
/*****************************************************************************
* FUNCTION: isMacAddress
*
* RETURNS: True if valid MAC address, else False
*
* PARAMS: p_string -- string to check
* p_Address -- Array where MAC values will be written
*
* NOTES: Determines if the input string is a valid MAC address.
* If it is, then returns an array of 6 bytes for each of the values.
* MAC address must be in hex in the format xx:xx:xx:xx:xx:xx
*****************************************************************************/
static bool isMacAddress(int8_t *p_string, uint8_t *p_Address)
{
uint8_t i;
uint16_t tmp;
if (strlen((char *)p_string) != 17u)
{
return false;
}
// ensure the ':' is in the right place, and if so, set them to 0
for (i = 2; i < 17u; i += 3)
{
if (p_string[i] == (int8_t)':')
{
p_string[i] = '\0';
}
else
{
return false;
}
}
// now extract each hex number string
for (i = 0; i < 6u; ++i)
{
if (!ConvertASCIIHexToBinary(&p_string[i * 3], &tmp))
{
return false;
}
p_Address[i] = (uint8_t) (tmp & 0xFF);
}
return true;
}
/*****************************************************************************
* FUNCTION: isMacAddress
*
* RETURNS: True if valid MAC address, else False
*
* PARAMS: p_string -- string to check
* p_Address -- Array where MAC values will be written
*
* NOTES: Determines if the input string is a valid MAC address.
* If it is, then returns an array of 6 bytes for each of the values.
* MAC address must be in hex in the format xx:xx:xx:xx:xx:xx
*****************************************************************************/
static BOOL isMacAddress(INT8 *p_string, UINT8 *p_Address)
{
UINT8 i;
UINT16 tmp;
if (strlen((char *)p_string) != 17u)
{
return FALSE;
}
// ensure the ':' is in the right place, and if so, set them to 0
for (i = 2; i < 17u; i += 3)
{
if (p_string[i] == (INT8)':')
{
p_string[i] = '\0';
}
else
{
return FALSE;
}
}
// now extract each hex number string
for (i = 0; i < 6u; ++i)
{
if (!ConvertASCIIHexToBinary(&p_string[i * 3], &tmp))
{
return FALSE;
}
p_Address[i] = (UINT8) (tmp & 0xFF);
}
return TRUE;
}
