static void gdb_read_mem()
{
static u8 reply[GDB_BFR_MAX - 4];
u32 addr, len;
u32 i;
i = 1;
addr = 0;
while (cmd_bfr[i] != ',')
addr = (addr << 4) | hex2char(cmd_bfr[i++]);
i++;
len = 0;
while (i < cmd_len)
len = (len << 4) | hex2char(cmd_bfr[i++]);
DEBUG_LOG(GDB_STUB, "gdb: read memory: %08x bytes from %08x", len, addr);
if (len * 2 > sizeof reply)
gdb_reply("E01");
u8* data = Memory::GetPointer(addr);
if (!data)
return gdb_reply("E0");
mem2hex(reply, data, len);
reply[len * 2] = '\0';
gdb_reply((char*)reply);
}
int POCO_CVT::str2char(const char* str, char& c)
{
if( str == NULL ) {
c = '\0';
return 1;
}
int len = strlen(str);
if( len == 1 ) {
c = str[0];
return 1;
}
if( len >= 3
&& str[0] == '0'
&& (str[1] == 'x' || str[1] == 'X') ) {
if( hex2char(str[2], c) == 0 ) {
return 0;
}
if( len > 3 ) {
char a;
if( hex2char(str[3], a) == 0 ) {
return 0;
}
c = c*0x10 + a;
}
}
return 1;
}
static void hex2mem(u8* dst, u8* src, u32 len)
{
while (len-- > 0)
{
*dst++ = (hex2char(*src) << 4) | hex2char(*(src + 1));
src += 2;
}
}
void buildAndCheckSentence(unsigned char characterIn) {
// Full specification for NMEA0138 specifies a maximum sentence length
// of 255 characters. We're going to ignore this for half the length as
// we shouldn't get anything that big.
// This contains the function's state of whether
// it is currently building a sentence.
// 0 - Awaiting start character ($)
// 1 - Building sentence
// 2 - Building first checksum character
// 3 - Building second checksum character
//printf("char: %c\r\n",characterIn);
// We start recording a new sentence if we see a dollarsign.
// The sentenceIndex is hard-set to 1 so that multiple dollar-signs
// keep you at the beginning.
if (characterIn == '$') {
//printf("start character at least");
sentence[0] = characterIn;
sentenceIndex = 1;
sentenceState = 1;
} else if (sentenceState == 1) {
// Record every character that comes in now that we're building a sentence.
// Only stop if we run out of room or an asterisk is found.
sentence[sentenceIndex++] = characterIn;
if (characterIn == '*') {
sentenceState = 2;
} else if (sentenceIndex > 127) {
// If we've filled up the buffer, ignore the entire message as we can't store it all
sentenceState = 0;
sentenceIndex = 0;
}
} else if (sentenceState == 2) {
// Record the first ASCII-hex character of the checksum byte.
checksum = hex2char(characterIn) << 4;
sentenceState = 3;
} else if (sentenceState == 3) {
// Record the second ASCII-hex character of the checksum byte.
checksum |= hex2char(characterIn);
// Now that we've compiled a complete GPS sentence, let's check the checksum and parse it.
// This code currently only supports RMC and GGA messages.
if (checksum == getChecksum(sentence, sentenceIndex)) {
if (sentence[3] == 'R' &&
sentence[4] == 'M' &&
sentence[5] == 'C') {
parseRMC(sentence);
} else if (sentence[3] == 'G' &&
sentence[4] == 'G' &&
sentence[5] == 'A') {
parseGGA(sentence);
}
}
// We clear all state variables here regardless of success.
sentenceIndex = 0;
sentenceState = 0;
}
}
static void gdb_read_command()
{
u8 c;
u8 chk_read, chk_calc;
cmd_len = 0;
memset(cmd_bfr, 0, sizeof cmd_bfr);
c = gdb_read_byte();
if (c == '+')
{
// ignore ack
return;
}
else if (c == 0x03)
{
CPU::Break();
gdb_signal(GDB_SIGTRAP);
return;
}
else if (c != GDB_STUB_START)
{
DEBUG_LOG(GDB_STUB, "gdb: read invalid byte %02x", c);
return;
}
while ((c = gdb_read_byte()) != GDB_STUB_END)
{
cmd_bfr[cmd_len++] = c;
if (cmd_len == sizeof cmd_bfr)
{
ERROR_LOG(GDB_STUB, "gdb: cmd_bfr overflow");
gdb_nak();
return;
}
}
chk_read = hex2char(gdb_read_byte()) << 4;
chk_read |= hex2char(gdb_read_byte());
chk_calc = gdb_calc_chksum();
if (chk_calc != chk_read)
{
ERROR_LOG(GDB_STUB,
"gdb: invalid checksum: calculated %02x and read %02x for $%s# (length: %d)",
chk_calc, chk_read, cmd_bfr, cmd_len);
cmd_len = 0;
gdb_nak();
return;
}
DEBUG_LOG(GDB_STUB, "gdb: read command %c with a length of %d: %s", cmd_bfr[0], cmd_len, cmd_bfr);
gdb_ack();
}
/**@brief Constructs String as string representation of byte sequence in hex form.
* e.g 234F11A1...*/
String String::fromByteArray(const ByteArray& bytes)
{
if(bytes.empty())
return String();
String result;
for(ByteArray::const_iterator i = bytes.begin(); i != bytes.end(); ++i)
{
result += hex2char(((*i)/0x10)%0x10);
result += hex2char((*i)%0x10);
}
return result;
}
static void gdb_write_register()
{
u32 id;
u8* bufptr = cmd_bfr + 3;
id = hex2char(cmd_bfr[1]);
if (cmd_bfr[2] != '=')
{
++bufptr;
id <<= 4;
id |= hex2char(cmd_bfr[2]);
}
switch (id)
{
case 0 ... 31:
GPR(id) = re32hex(bufptr);
break;
case 32 ... 63:
riPS0(id - 32) = re64hex(bufptr);
break;
case 64:
PC = re32hex(bufptr);
break;
case 65:
MSR.Hex = re32hex(bufptr);
break;
case 66:
PowerPC::SetCR(re32hex(bufptr));
break;
case 67:
LR = re32hex(bufptr);
break;
case 68:
CTR = re32hex(bufptr);
break;
case 69:
PowerPC::ppcState.spr[SPR_XER] = re32hex(bufptr);
break;
case 70:
// do nothing, we dont have MQ
break;
case 71:
FPSCR.Hex = re32hex(bufptr);
break;
default:
return gdb_reply("E01");
break;
}
gdb_reply("OK");
}
static void gdb_read_register()
{
static u8 reply[64];
u32 id;
memset(reply, 0, sizeof reply);
id = hex2char(cmd_bfr[1]);
if (cmd_bfr[2] != '\0')
{
id <<= 4;
id |= hex2char(cmd_bfr[2]);
}
switch (id)
{
case 0 ... 31:
wbe32hex(reply, GPR(id));
break;
case 32 ... 63:
wbe64hex(reply, riPS0(id - 32));
break;
case 64:
wbe32hex(reply, PC);
break;
case 65:
wbe32hex(reply, MSR.Hex);
break;
case 66:
wbe32hex(reply, PowerPC::GetCR());
break;
case 67:
wbe32hex(reply, LR);
break;
case 68:
wbe32hex(reply, CTR);
break;
case 69:
wbe32hex(reply, PowerPC::ppcState.spr[SPR_XER]);
break;
case 70:
wbe32hex(reply, 0x0BADC0DE);
break;
case 71:
wbe32hex(reply, FPSCR.Hex);
break;
default:
return gdb_reply("E01");
break;
}
gdb_reply((char*)reply);
}
void buildAndCheckSentence(unsigned char characterIn, char *sentence, unsigned char *sentenceIndex, unsigned char *sentenceState, unsigned char *checksum, void (*processResult)(char *)) {
// Full specification for NMEA0138 specifies a maximum sentence length
// of 255 characters. We're going to ignore this for half the length as
// we shouldn't get anything that big.
// This contains the function's state of whether
// it is currently building a sentence.
// 0 - Awaiting start character ($)
// 1 - Building sentence
// 2 - Building first checksum character
// 3 - Building second checksum character
// We start recording a new sentence if we see a dollarsign.
// The sentenceIndex is hard-set to 1 so that multiple dollar-signs
// keep you at the beginning.
if ((*sentenceState) == 0) {
if (characterIn == '$') {
(*sentenceIndex) = 0;
(*sentenceState) = 1;
}
} else if ((*sentenceState) == 1) {
// Record every character that comes in now that we're building a sentence.
// Only stop if we run out of room or an asterisk is found.
if (characterIn == '*') {
(*sentenceState) = 2;
} else if ((*sentenceIndex) > 127) {
// If we've filled up the buffer, ignore the entire message as we can't store it all
(*sentenceState) = 0;
} else {
sentence[(*sentenceIndex)++] = characterIn;
}
} else if ((*sentenceState) == 2) {
// Record the first ASCII-hex character of the checksum byte.
(*checksum) = hex2char(characterIn) << 4;
(*sentenceState) = 3;
} else if ((*sentenceState) == 3) {
// Record the second ASCII-hex character of the checksum byte.
(*checksum) |= hex2char(characterIn);
// Now that we've compiled a complete GPS sentence, let's check the checksum and parse it.
// This code currently only supports RMC and GGA messages.
unsigned char test = getChecksum(sentence, (*sentenceIndex));
if ((*checksum) == test) {
processResult(sentence);
}
// We clear all state variables here regardless of success.
(*sentenceState) = 0;
}
}
void
gdb_write_to_packet_hex(unsigned long x, int int_size, struct gdb_context *ctx)
{
char buf[sizeof(unsigned long) * 2 + 1];
int i = sizeof(unsigned long) * 2;
int width = int_size * 2;
buf[sizeof(unsigned long) * 2] = 0;
switch ( int_size )
{
case sizeof(u8):
case sizeof(u16):
case sizeof(u32):
case sizeof(u64):
break;
default:
dbg_printk("WARNING: %s x: 0x%lx int_size: %d\n",
__func__, x, int_size);
break;
}
do {
buf[--i] = hex2char(x & 15);
x >>= 4;
} while ( x );
while ( (i + width) > (sizeof(unsigned long) * 2) )
buf[--i] = '0';
gdb_write_to_packet(&buf[i], width, ctx);
}
void
dbg_print_val(const char* s, unsigned long num)
{
#ifdef DEBUG
for ( ; *s != '\0'; s++) {
if (*s == '\n') {
putc('\r');
putc('\n');
} else if (*s == '%') {
s++;
if (*s == 'c') {
putc(*(char *)num);
} else if (*s == 's') {
dbg_print((char *)num);
} else if (*s == 'x') {
hex2char(num);
} else {
putc('%');
putc(*s);
}
} else {
putc(*s);
}
}
#endif
}
string printByHex(const unsigned char* message, const int length)
{
string out;
for (int i = 0; i < length; i++)
{
int k = (unsigned char)*(message + i)/ 16;
out += hex2char(k);
k = (unsigned char)*(message + i)% 16;
out += hex2char(k);
out += " ";
}
// LOG_DEBUG(out);
return out;
}
void
gdb_write_to_packet_hex(unsigned long x, int int_size, struct gdb_context *ctx)
{
char buf[sizeof(unsigned long) * 2 + 1];
int i, width = int_size * 2;
buf[sizeof(unsigned long) * 2] = 0;
switch ( int_size )
{
case sizeof(u8):
case sizeof(u16):
case sizeof(u32):
case sizeof(u64):
break;
default:
dbg_printk("WARNING: %s x: 0x%lx int_size: %d\n",
__func__, x, int_size);
break;
}
#ifdef __BIG_ENDIAN
i = sizeof(unsigned long) * 2
do {
buf[--i] = hex2char(x & 15);
x >>= 4;
} while ( x );
while ( (i + width) > (sizeof(unsigned long) * 2) )
buf[--i] = '0';
gdb_write_to_packet(&buf[i], width, ctx);
#elif defined(__LITTLE_ENDIAN)
i = 0;
while ( i < width )
{
buf[i++] = hex2char(x>>4);
buf[i++] = hex2char(x);
x >>= 8;
}
gdb_write_to_packet(buf, width, ctx);
#else
# error unknown endian
#endif
}
static int hexdump(char* buf, const char* ptr, size_t length)
{
int idx = 0;
buf[idx++] = '0';
buf[idx++] = 'x';
for (int i = 0; i < length; ++i) {
#if (defined __BIG_ENDIAN__)
const unsigned char c = ptr[i];
#else
const unsigned char c = ptr[length - 1 - i];
#endif
buf[idx++] = hex2char(c / 16);
buf[idx++] = hex2char(c % 16);
}
return idx;
}
static u32 re32hex(u8* p)
{
u32 i;
u32 res = 0;
for (i = 0; i < 8; i++)
res = (res << 4) | hex2char(p[i]);
return res;
}
static u64 re64hex(u8* p)
{
u32 i;
u64 res = 0;
for (i = 0; i < 16; i++)
res = (res << 4) | hex2char(p[i]);
return res;
}
/* RFC */
void unescape_url(char *url)
{
int n, k;
for (n = 0, k = 0; url[k]; ++n, ++k) {
if ((url[n] = url[k]) == '%') {
url[n] = hex2char(&url[k + 1]);
k += 2;
}
}
url[n] = '\0';
}
int gdbr_write_registers(libgdbr_t* g, char* registers) {
// read current register set
gdbr_read_registers(g);
int x, len = strlen(registers);
char* buff = calloc(len, sizeof(char));
memcpy(buff, registers, len);
char* reg = strtok(buff, ",");
while ( reg != NULL ) {
char* name_end = strchr(reg, '=');
if (name_end == NULL) {
printf("Malformed argument: %s\n", reg);
free(buff);
return -1;
}
*name_end = '\0'; // change '=' to '\0'
// time to find the current register
int i = 0;
while ( g->registers[i].size > 0) {
if (strcmp(g->registers[i].name, reg) == 0) {
uint64_t register_size = g->registers[i].size;
uint64_t offset = g->registers[i].offset;
char* value = calloc (register_size * 2, sizeof(char));
memset (value, '0', register_size * 2);
name_end++;
// be able to take hex with and without 0x
if (name_end[1] == 'x' || name_end[1] == 'X') name_end += 2;
int val_len = strlen (name_end); // size of the rest
strcpy (value+(register_size * 2 - val_len), name_end);
for (x=0; x < register_size; x++) {
g->data[offset + register_size - x - 1] = hex2char(&value[x * 2]);
}
free(value);
}
i++;
}
reg = strtok(NULL, " ,");
}
free(buff);
uint64_t buffer_size = g->data_len * 2 + 8;
char* command = calloc(buffer_size, sizeof(char));
snprintf (command, buffer_size, "%s", CMD_WRITEREGS);
pack_hex (g->data, g->data_len, command+1);
send_command (g, command);
read_packet (g);
free (command);
handle_G (g);
return 0;
}
// key是静态文本，简单转化一下更好
// 客户端需这般处理，服务端不需要
std::string se(std::string src)
{
string result;
int len = src.length();
for (int i = 0; i < len; i++) {
int sum = src[i]*2 + i/2;
result += hex2char( sum%16 );
}
return result;
}
void scan_ex(void)
{
lcd_goto(0x40);
char ad = 0x00;
char test;
char before_div;
char dived_data[2];
lcd_goto(0x00);
while(1)
{
test = getch();
data_div(test, dived_data);
dived_data[0] = hex2char(dived_data[0]);
dived_data[1] = hex2char(dived_data[1]);
if(ad == 0x0F)
ad = 0x40;
else if(ad == 0x4F)
ad = 0x00;
else
ad++;
lcd_goto(ad);
lcd_putch(dived_data[0]);
if(ad == 0x0F)
ad = 0x40;
else if(ad == 0x4F)
ad = 0x00;
else
ad++;
lcd_goto(ad);
lcd_putch(dived_data[1]);
}
}
static void gdb_write_mem()
{
u32 addr, len;
u32 i;
i = 1;
addr = 0;
while (cmd_bfr[i] != ',')
addr = (addr << 4) | hex2char(cmd_bfr[i++]);
i++;
len = 0;
while (cmd_bfr[i] != ':')
len = (len << 4) | hex2char(cmd_bfr[i++]);
DEBUG_LOG(GDB_STUB, "gdb: write memory: %08x bytes to %08x", len, addr);
u8* dst = Memory::GetPointer(addr);
if (!dst)
return gdb_reply("E00");
hex2mem(dst, cmd_bfr + i + 1, len);
gdb_reply("OK");
}
// Hex code solver for a given string.
std::string stringSolver(const std::string& hexMessage)
{
// Tokenize the encoded message
std::vector<std::string> tokens;
boost::split(tokens, hexMessage, boost::is_any_of(", \r\n"), boost::token_compress_on);
std::vector<char> ret(tokens.size());
ret.clear();
for (auto tok : tokens) {
if(!tok.empty())
ret.push_back(hex2char(tok));
}
return std::string(&ret[0], ret.size() * sizeof(char));
}
static void gdb_remove_bp()
{
u32 type, addr, len, i;
type = hex2char(cmd_bfr[1]);
switch (type)
{
case 0:
case 1:
type = GDB_BP_TYPE_X;
break;
case 2:
type = GDB_BP_TYPE_W;
break;
case 3:
type = GDB_BP_TYPE_R;
break;
case 4:
type = GDB_BP_TYPE_A;
break;
default:
return gdb_reply("E01");
}
addr = 0;
len = 0;
i = 3;
while (cmd_bfr[i] != ',')
addr = (addr << 4) | hex2char(cmd_bfr[i++]);
i++;
while (i < cmd_len)
len = (len << 4) | hex2char(cmd_bfr[i++]);
gdb_bp_remove(type, addr, len);
gdb_reply("OK");
}
static void _gdb_add_bp()
{
u32 type;
u32 i, addr = 0, len = 0;
type = hex2char(cmd_bfr[1]);
switch (type)
{
case 0:
case 1:
type = GDB_BP_TYPE_X;
break;
case 2:
type = GDB_BP_TYPE_W;
break;
case 3:
type = GDB_BP_TYPE_R;
break;
case 4:
type = GDB_BP_TYPE_A;
break;
default:
return gdb_reply("E01");
}
i = 3;
while (cmd_bfr[i] != ',')
addr = addr << 4 | hex2char(cmd_bfr[i++]);
i++;
while (i < cmd_len)
len = len << 4 | hex2char(cmd_bfr[i++]);
if (!gdb_add_bp(type, addr, len))
return gdb_reply("E02");
gdb_reply("OK");
}
void long2ascii( signed long input_long, char * target_string )
{
//Vars
long decumulator;
//int dec_fact = 10;
char out_buffer[10];
char target_string_ptr = 0;
int out_buffer_ptr;
//take care of the pesky negative.
if( input_long < 0 )
{
target_string[target_string_ptr] = '-';
target_string_ptr++;
decumulator = input_long ^ 0xFFFFFFFF; //convert to positive
decumulator++;
}
else
{
decumulator = input_long; //Leave as positive
}
//Perform the modulus math
for( out_buffer_ptr = 0; out_buffer_ptr < 10; out_buffer_ptr++ )
{
//perform the mod
//buffer the base 10 value
int temp = ( decumulator % 10 );
out_buffer[out_buffer_ptr] = temp;
//decrement the decumulator-- get rid of the last remainder and divide by 10
decumulator = (decumulator - out_buffer[out_buffer_ptr]) / 10;
//multiply by 10
//dec_fact = dec_fact * 10;
}
//Now convert the base 10 int array to the string
//First seek first non-zero place
for( out_buffer_ptr = 9; (out_buffer[out_buffer_ptr] == 0) && (out_buffer_ptr > 0) ; out_buffer_ptr-- ); //oh, look at that tricky shit!
//roll out the out_buffer upwards till pointer = 0
for( ; out_buffer_ptr >= 0; out_buffer_ptr-- ) //What is this? Is it even valid?
{
target_string[target_string_ptr] = hex2char(out_buffer[out_buffer_ptr]);
target_string_ptr++;
}
//slap a null on it
target_string[target_string_ptr] = 0x00;
return;
}
static void
gdbstub_console_puts(const char *str)
{
const char *p;
gdb_start_packet(gdb_ctx);
gdb_write_to_packet_char('O', gdb_ctx);
for ( p = str; *p != '\0'; p++ )
{
gdb_write_to_packet_char(hex2char((*p>>4) & 0x0f), gdb_ctx );
gdb_write_to_packet_char(hex2char((*p) & 0x0f), gdb_ctx );
}
gdb_send_packet(gdb_ctx);
}
const char* hex2str(const char* bin, int bin_size, char* buff, int buff_size)
{
char* nptr = buff;
if (NULL == buff) {
return "buffer is NULL";
}
if (buff_size < bin_size*2+1) {
return "buffer too small";
}
while (bin_size--) {
nptr = hex2char(nptr, *bin++);
}
*nptr = 0;
return buff;
}
// md5加密后，根据key获得校验码
std::string mcc(std::string param, std::string key)
{
string result;
string md5Param = md5( param );
int paramLenght = param.length();
int keyLenght = param.length();
int j = 0;
for (int i = 0; i < paramLenght; i++) {
if (j < keyLenght-1) {
j++;
} else {
j = keyLenght/2;
}
int sum = param[i] + key[j] + i*2 + j*3;
result += hex2char( sum%16 ); //求余并转为16进制
}
return result;
}
int main (int argc, char *argv[])
{
FILE *fp = NULL;
char *buf = NULL, *getbuf(void);
fpos_t rpos;
int i, patterns, max_bytes = 0;
LOGICAL hex2char(const char *, char *);
if (2 > argc) /* no filename */
return 1;
if (3 > argc) /* no argument */
return 2;
if (NULL == (fp = fopen(argv[1], "r+b")))
return 3; /* file open error */
if (NULL == (buf = getbuf()))
return 4; /* no memory for buffer */
patterns = argc - 2; /* process arguments */
for (i = 2; i < argc; ++i)
{
char *p, *ptr;
if (NULL != (ptr = strtok(argv[i], ",")))
{
p = search[i - 2].pattern;
do
{
search[i - 2].numbytes++;
if (1 == strlen(ptr))
{
*p++ = *ptr;
continue;
}
switch (toupper(LAST_CHAR(ptr)))
{
case 'D':
LAST_CHAR(ptr) = '\0';
*p++ = (char)atoi(ptr);
break;
case 'H':
LAST_CHAR(ptr) = '\0';
if (ERROR == hex2char(ptr, p++))
return 5;
break;
default:
return 5;
}
} while (NULL != (ptr = strtok(NULL, ",")));
*p = '\0';
max_bytes = max(max_bytes, search[i - 2].numbytes);
}
else return 5;
}
fgetpos(fp, &rpos); /* save where we are */
while (1)
{
int bytes, n;
LOGICAL modified;
if (max_bytes > (bytes = (int)fread(buf, 1, bufsize, fp)))
{
if (0 == bytes && !feof(fp))
return 6; /* something's wrong! */
else break; /* all done! */
}
for (n = 0, modified = FALSE; n < patterns; ++n)
{
/* check each pattern in turn */
for (i = 0; i < (bytes - max_bytes + 1); ++i)
{
int j;
if (buf[i] != *(search[n].pattern))
continue;
if (SUCCESS != strncmp(&buf[i],
search[n].pattern, search[n].numbytes))
{
continue;
}
/* found one! replace it in the buffer */
for (j = 0; j < search[n].numbytes; ++j, ++i)
buf[i] = '\0';
modified = TRUE;
}
}
if (modified) /* write changes, if any*/
{
fpos_t wpos = rpos;
fsetpos(fp, &wpos);
if (bytes != (int)fwrite(buf, 1, bytes, fp))
return 7;
fsetpos(fp, &rpos);
}
rpos += bytes - max_bytes + 1; /* get another buffer */
fsetpos(fp, &rpos);
}
fclose(fp);
return SUCCESS;
}
int gdbr_write_registers(libgdbr_t *g, char *registers) {
uint64_t buffer_size;
int ret, i = 0;
unsigned int x, len;
char *command, *reg, *buff;
// read current register set
if (!g) {
return -1;
}
gdbr_read_registers (g);
reg_cache.valid = false;
len = strlen (registers);
buff = calloc (len, sizeof (char));
if (!buff) {
return -1;
}
memcpy (buff, registers, len);
reg = strtok (buff, ",");
while (reg != NULL) {
char *name_end = strchr (reg, '=');
if (name_end == NULL) {
eprintf ("Malformed argument: %s\n", reg);
free (buff);
return -1;
}
*name_end = '\0'; // change '=' to '\0'
// time to find the current register
while (g->registers[i].size > 0) {
if (strcmp (g->registers[i].name, reg) == 0) {
const ut64 register_size = g->registers[i].size;
const ut64 offset = g->registers[i].offset;
char *value = calloc (register_size + 1, 2);
if (!value) {
free (buff);
return -1;
}
memset (value, '0', register_size * 2);
name_end++;
// be able to take hex with and without 0x
if (name_end[1] == 'x' || name_end[1] == 'X') {
name_end += 2;
}
const int val_len = strlen (name_end); // size of the rest
strcpy (value + (register_size * 2 - val_len), name_end);
for (x = 0; x < register_size; x++) {
g->data[offset + register_size - x - 1] = hex2char (&value[x * 2]);
}
free (value);
}
i++;
}
reg = strtok (NULL, " ,");
}
free (buff);
buffer_size = g->data_len * 2 + 8;
command = calloc (buffer_size, sizeof(char));
if (!command) {
return -1;
}
snprintf (command, buffer_size, "%s", CMD_WRITEREGS);
pack_hex (g->data, g->data_len, command + 1);
ret = send_msg (g, command);
if (ret < 0) {
free (command);
return ret;
}
read_packet (g);
free (command);
handle_G (g);
return 0;
}
