/// \brief Encode a Buffer from a hex string.
///
/// @param str A hex string, ex... "00 03 05 0a"
///
/// @return A reference to a Buffer in host endian format. This is
/// primary used only for testing to create binary data
/// from an easy to read and edit format.
Buffer &
Buffer::hex2mem(const std::string &str)
{
// GNASH_REPORT_FUNCTION;
size_t count = str.size();
size_t size = (count/3) + 4;
boost::uint8_t ch = 0;
boost::uint8_t *ptr = const_cast<boost::uint8_t *>(reinterpret_cast<const boost::uint8_t *>(str.c_str()));
boost::uint8_t *end = ptr + count;
init(size);
for (size_t i=0; ptr<end; i++) {
if (*ptr == ' ') { // skip spaces.
ptr++;
continue;
}
ch = hex2digit(*ptr++) << 4;
ch |= hex2digit(*ptr++);
*this += ch;
i++;
}
resize(size);
return *this;
}
/*
* Scan for the sequence $<data>#<checksum>
*/
void
getpacket(unsigned char *buffer)
{
unsigned char checksum;
unsigned char xmitcsum;
int i;
int count;
unsigned char ch;
do {
/* wait around for the start character, ignore all other characters */
while ((ch = (inbyte() & 0x7f)) != '$') ;
checksum = 0;
xmitcsum = -1;
count = 0;
/* now, read until a # or end of buffer is found */
while (count < BUFMAX) {
ch = inbyte() & 0x7f;
if (ch == '#')
break;
checksum = checksum + ch;
buffer[count] = ch;
count = count + 1;
}
if (count >= BUFMAX)
continue;
buffer[count] = 0;
if (ch == '#') {
xmitcsum = hex2digit(inbyte() & 0x7f) << 4;
xmitcsum |= hex2digit(inbyte() & 0x7f);
#if 1
/* Humans shouldn't have to figure out checksums to type to it. */
outbyte ('+');
return;
#endif
if (checksum != xmitcsum)
outbyte('-'); /* failed checksum */
else {
outbyte('+'); /* successful transfer */
/* if a sequence char is present, reply the sequence ID */
if (buffer[2] == ':') {
outbyte(buffer[0]);
outbyte(buffer[1]);
/* remove sequence chars from buffer */
count = strlen(buffer);
for (i=3; i <= count; i++)
buffer[i-3] = buffer[i];
}
}
}
}
while (checksum != xmitcsum);
}
/*
* Convert the hex array pointed to by buf into binary to be placed in mem
* return a pointer to the character AFTER the last byte written
*/
unsigned char *
hex2mem(unsigned char *buf, unsigned char *mem, int count, int may_fault)
{
int i;
unsigned char ch;
DEBUG (1, "In hex2mem");
set_mem_fault_trap(may_fault);
for (i=0; i<count; i++) {
ch = hex2digit(*buf++) << 4;
ch |= hex2digit(*buf++);
*mem++ = ch;
if (mem_err)
return 0;
}
set_mem_fault_trap(0);
return mem;
}
static void guid_to_str( GUID *guid, pj_str_t *str )
{
unsigned i;
const unsigned char *src = (const unsigned char*)guid;
char *dst = str->ptr;
guid->Data1 = pj_ntohl(guid->Data1);
guid->Data2 = pj_ntohs(guid->Data2);
guid->Data3 = pj_ntohs(guid->Data3);
for (i=0; i<16; ++i) {
hex2digit( *src, dst );
dst += 2;
++src;
}
str->slen = 32;
}
/*
* while we find nice hex chars, build an int.
* param is a pointer to the string.
* returns the int in the param field, and the number of chars processed.
*/
int
hex2int (char **ptr, int *intValue)
{
int numChars = 0;
int hexValue;
*intValue = 0;
while (**ptr)
{
hexValue = hex2digit(**ptr);
if (hexValue < 0)
break;
*intValue = (*intValue << 4) | hexValue;
numChars ++;
(*ptr)++;
}
return (numChars);
}
bool handle_line(const char *data, size_t datalen, void *pw)
{
line_ctx *ctx = (line_ctx *) pw;
if (data[0] == '#') {
if (ctx->inexp) {
/* This marks end of testcase, so run it */
if (ctx->buf[ctx->bufused - 1] == '\n')
ctx->bufused -= 1;
if (ctx->exp[ctx->expused - 1] == '\n')
ctx->expused -= 1;
run_test(ctx);
ctx->buf[0] = '\0';
ctx->exp[0] = '\0';
ctx->bufused = 0;
ctx->expused = 0;
ctx->exp_ret = PARSERUTILS_OK;
}
if (strncasecmp(data+1, "data", 4) == 0) {
parserutils_charset_codec_optparams params;
const char *ptr = data + 6;
ctx->indata = true;
ctx->inexp = false;
if (strncasecmp(ptr, "decode", 6) == 0)
ctx->dir = DECODE;
else if (strncasecmp(ptr, "encode", 6) == 0)
ctx->dir = ENCODE;
else
ctx->dir = BOTH;
ptr += 7;
if (strncasecmp(ptr, "LOOSE", 5) == 0) {
params.error_mode.mode =
PARSERUTILS_CHARSET_CODEC_ERROR_LOOSE;
ptr += 6;
} else if (strncasecmp(ptr, "STRICT", 6) == 0) {
params.error_mode.mode =
PARSERUTILS_CHARSET_CODEC_ERROR_STRICT;
ptr += 7;
} else {
params.error_mode.mode =
PARSERUTILS_CHARSET_CODEC_ERROR_TRANSLIT;
ptr += 9;
}
assert(parserutils_charset_codec_setopt(ctx->codec,
PARSERUTILS_CHARSET_CODEC_ERROR_MODE,
(parserutils_charset_codec_optparams *) ¶ms)
== PARSERUTILS_OK);
} else if (strncasecmp(data+1, "expected", 8) == 0) {
ctx->indata = false;
ctx->inexp = true;
ctx->exp_ret = parserutils_error_from_string(data + 10,
datalen - 10 - 1 /* \n */);
} else if (strncasecmp(data+1, "reset", 5) == 0) {
ctx->indata = false;
ctx->inexp = false;
parserutils_charset_codec_reset(ctx->codec);
}
} else {
if (ctx->indata) {
/* Process "&#xNNNN" as 16-bit code units. */
while (datalen) {
uint16_t nCodePoint;
if (data[0] == '\n') {
ctx->buf[ctx->bufused++] = *data++;
--datalen;
continue;
}
assert(datalen >= sizeof ("&#xNNNN")-1 \
&& data[0] == '&' && data[1] == '#' \
&& data[2] == 'x' && isxdigit(data[3]) \
&& isxdigit(data[4]) && isxdigit(data[5]) \
&& isxdigit(data[6]));
/* UTF-16 code is always host endian (different
than UCS-32 !). */
nCodePoint = (hex2digit(data[3]) << 12) |
(hex2digit(data[4]) << 8) |
(hex2digit(data[5]) << 4) |
hex2digit(data[6]);
*((uint16_t *) (void *) (ctx->buf + ctx->bufused)) =
nCodePoint;
ctx->bufused += 2;
data += sizeof ("&#xNNNN")-1;
datalen -= sizeof ("&#xNNNN")-1;
}
}
if (ctx->inexp) {
/* Process "&#xXXXXYYYY as 32-bit code units. */
while (datalen) {
uint32_t nCodePoint;
if (data[0] == '\n') {
ctx->exp[ctx->expused++] = *data++;
--datalen;
continue;
}
assert(datalen >= sizeof ("&#xXXXXYYYY")-1 \
&& data[0] == '&' && data[1] == '#' \
&& data[2] == 'x' && isxdigit(data[3]) \
&& isxdigit(data[4]) && isxdigit(data[5]) \
&& isxdigit(data[6]) && isxdigit(data[7]) \
&& isxdigit(data[8]) && isxdigit(data[9]) \
&& isxdigit(data[10]));
/* UCS-4 code is always big endian, so convert
host endian to big endian. */
nCodePoint =
htonl((hex2digit(data[3]) << 28)
| (hex2digit(data[4]) << 24)
| (hex2digit(data[5]) << 20)
| (hex2digit(data[6]) << 16)
| (hex2digit(data[7]) << 12)
| (hex2digit(data[8]) << 8)
| (hex2digit(data[9]) << 4)
| hex2digit(data[10]));
*((uint32_t *) (void *) (ctx->exp + ctx->expused)) =
nCodePoint;
ctx->expused += 4;
data += sizeof ("&#xXXXXYYYY")-1;
datalen -= sizeof ("&#xXXXXYYYY")-1;
}
}
}
return true;
}
