char* parse_string(const std::string & s)
{
char* buffer = new char[s.size() / 2];
for (std::size_t i = 0; i != s.size() / 2; ++i)
buffer[i] = 16 * parse_hex(s[2 * i]) + parse_hex(s[2 * i + 1]);
return buffer;
}
/**
* Call for chars after a backlash to decode the escape sequence.
*
* Stores the result in *ch.
*
* Returns the number of bytes consumed.
*/
static int reg_decode_escape(const char *s, int *ch)
{
int n;
const char *s0 = s;
*ch = *s++;
switch (*ch) {
case 'b': *ch = '\b'; break;
case 'e': *ch = 27; break;
case 'f': *ch = '\f'; break;
case 'n': *ch = '\n'; break;
case 'r': *ch = '\r'; break;
case 't': *ch = '\t'; break;
case 'v': *ch = '\v'; break;
case 'u':
if ((n = parse_hex(s, 4, ch)) > 0) {
s += n;
}
break;
case 'x':
if ((n = parse_hex(s, 2, ch)) > 0) {
s += n;
}
break;
case '\0':
s--;
*ch = '\\';
break;
}
return s - s0;
}
unsigned godob::read_quad(void)
{
unsigned long t0 = millis();
unsigned r=0;
while(Serial.available()<4 && millis()-t0<100);
if(Serial.available()>=4){
r = parse_hex(Serial.read())*0x1000;
r += parse_hex(Serial.read())*0x100;
r += parse_hex(Serial.read())*0x10;
r += parse_hex(Serial.read())*0x1;
}
return r;
}
/**
* Call for chars after a backlash to decode the escape sequence.
*
* Stores the result in *ch.
*
* Returns the number of bytes consumed.
*/
static int reg_decode_escape(const char *s, int *ch)
{
int n;
const char *s0 = s;
*ch = *s++;
switch (*ch) {
case 'b': *ch = '\b'; break;
case 'e': *ch = 27; break;
case 'f': *ch = '\f'; break;
case 'n': *ch = '\n'; break;
case 'r': *ch = '\r'; break;
case 't': *ch = '\t'; break;
case 'v': *ch = '\v'; break;
case 'u':
if (*s == '{') {
/* Expect \u{NNNN} */
n = parse_hex(s + 1, 6, ch);
if (n > 0 && s[n + 1] == '}' && *ch >= 0 && *ch <= 0x1fffff) {
s += n + 2;
}
else {
/* Invalid, so just treat as an escaped 'u' */
*ch = 'u';
}
}
else if ((n = parse_hex(s, 4, ch)) > 0) {
s += n;
}
break;
case 'U':
if ((n = parse_hex(s, 8, ch)) > 0) {
s += n;
}
break;
case 'x':
if ((n = parse_hex(s, 2, ch)) > 0) {
s += n;
}
break;
case '\0':
s--;
*ch = '\\';
break;
}
return s - s0;
}
int main(int argc, char *argv[]){
const char mac_addr[] = "01:02:03:04:05:ff";
parse_hex(mac_addr);
return 0;
}
bool Ublox::check_checksum()
{
if (buf[strlen(buf)-5] == '*')
{
uint16_t sum = parse_hex(buf[strlen(buf)-4]) * 16;
sum += parse_hex(buf[strlen(buf)-3]);
for (uint8_t i=1; i < (strlen(buf)-5); i++)
sum ^= buf[i];
if (sum != 0)
return false;
return true;
}
return false;
}
bool decode(std::string& s)
{
size_t pos = s.find(ENCODE_BEGIN_CHAR);
if (pos == std::string::npos)
{
// Handle the "99%" case fast.
return true;
}
std::string v;
for (size_t i = 0;;)
{
if (pos == std::string::npos)
{
v.append(s, i, s.size() - i); // Append up to end.
break;
}
v.append(s, i, pos - i); // Append up to char.
i = pos + 3; // Skip all 3 chars.
char c;
if (!parse_hex(s, pos + 1, c))
{
// Convert hex.
return false;
}
v.insert(v.end(), c); // Append converted hex.
pos = s.find(ENCODE_BEGIN_CHAR, i); // Find next
}
s = v;
return true;
}
TEST(SecurityManager, CMACTest){
mock_init();
mock_simulate_hci_state_working();
// expect le encrypt commmand
CHECK_HCI_COMMAND(test_command_packet_01);
aes128_report_result();
// expect le encrypt commmand
CHECK_HCI_COMMAND(test_command_packet_02);
aes128_report_result();
mock_clear_packet_buffer();
// additional test: cmac signing
// aes cmac tests
sm_key_t key;
parse_hex(key, key_string);
uint8_t message [] = "hallo";
cmac_hash_received = 0;
sm_cmac_signed_write_start(key, 0x11, 0x1234, sizeof(message), message, 1, &cmac_done);
while (!cmac_hash_received){
aes128_report_result();
}
uint8_t expected_hash[] = { 0x40, 0x4E, 0xDC, 0x0F, 0x6E, 0x0F, 0xF9, 0x5C};
CHECK_EQUAL_ARRAY(expected_hash, cmac_hash, 8);
// generic aes cmac tests
VALIDATE_MESSAGE(m0);
VALIDATE_MESSAGE(m16);
VALIDATE_MESSAGE(m40);
VALIDATE_MESSAGE(m64);
}
static int register_mgmt_frame(struct nl80211_state *state,
struct nl_msg *msg, int argc, char **argv,
enum id_input id)
{
unsigned int type;
unsigned char *match;
size_t match_len;
int ret;
ret = sscanf(argv[0], "%x", &type);
if (ret != 1) {
printf("invalid frame type: %s\n", argv[0]);
return 2;
}
match = parse_hex(argv[1], &match_len);
if (!match) {
printf("invalid frame pattern: %s\n", argv[1]);
return 2;
}
NLA_PUT_U16(msg, NL80211_ATTR_FRAME_TYPE, type);
NLA_PUT(msg, NL80211_ATTR_FRAME_MATCH, match_len, match);
return 0;
nla_put_failure:
return -ENOBUFS;
}
void read_dev_mcast(struct ma_info **result_p)
{
char buf[256];
FILE *fp = fopen(_PATH_PROCNET_DEV_MCAST, "r");
if (!fp)
return;
while (fgets(buf, sizeof(buf), fp)) {
char hexa[256];
struct ma_info m;
int len;
int st;
memset(&m, 0, sizeof(m));
sscanf(buf, "%d%s%d%d%s", &m.index, m.name, &m.users, &st,
hexa);
if (filter_dev[0] && strcmp(filter_dev, m.name))
continue;
m.addr.family = AF_PACKET;
len = parse_hex(hexa, (unsigned char*)&m.addr.data);
if (len >= 0) {
struct ma_info *ma = xmalloc(sizeof(m));
memcpy(ma, &m, sizeof(m));
ma->addr.bytelen = len;
ma->addr.bitlen = len<<3;
if (st)
ma->features = "static";
maddr_ins(result_p, ma);
}
}
fclose(fp);
}
void read_igmp6(struct ma_info **result_p)
{
char buf[256];
FILE *fp = fopen("/proc/net/igmp6", "r");
if (!fp)
return;
while (fgets(buf, sizeof(buf), fp)) {
char hexa[256];
struct ma_info m;
int len;
memset(&m, 0, sizeof(m));
sscanf(buf, "%d%s%s%d", &m.index, m.name, hexa, &m.users);
if (filter.dev && strcmp(filter.dev, m.name))
continue;
m.addr.family = AF_INET6;
len = parse_hex(hexa, (unsigned char*)&m.addr.data);
if (len >= 0) {
struct ma_info *ma = malloc(sizeof(m));
memcpy(ma, &m, sizeof(m));
ma->addr.bytelen = len;
ma->addr.bitlen = len<<3;
maddr_ins(result_p, ma);
}
}
fclose(fp);
}
static int parse(FileImpl* impl)
{
char* s = impl->line;
while ( isspace(*s) )
s++;
switch ( *s )
{
case '\0':
impl->line[0] = '\0';
return flush(impl);
case '#':
break;
case '$':
if ( impl->idx )
return flush(impl);
parse_command(impl, s+1);
break;
case '"':
parse_string(impl, s+1);
break;
case 'x':
parse_hex(impl, s+1);
break;
}
impl->line[0] = '\0';
return 0;
}
static char *parse_u24(char *p, u32 *valp)
{
u32 result = 0;
u32 tval;
p = parse_hex(p, &tval);
result |= tval << 0;
p = parse_hex(p, &tval);
result |= tval << 8;
p = parse_hex(p, &tval);
result |= tval << 16;
*valp = result;
return p;
}
bool parse_hex ( Octet &val, std::string const &s, std::string::size_type pos )
{
bool r=false;
if( s.length() >= pos+2 )
{
r=parse_hex(val,s[pos],s[pos+1]);
}
return r;
}
void parse_shared_pool(char *s)
{
char pool_type[3];
char buf[BUFSIZE];
unsigned long pool_id = parse(s,"PI");
unsigned long long uid0 = parse_hex(s,"U0");
unsigned long long uid1 = parse_hex(s,"U1");
unsigned long long pgp_count = parse(s,"Pc");
unsigned long long max_pgp_count = parse(s,"Pm");
unsigned long long obj_count = parse(s,"Oc");
unsigned long long max_obj_count = parse(s,"Om");
unsigned long long objnode_count = parse(s,"Nc");
unsigned long long max_objnode_count = parse(s,"Nm");
unsigned long long good_puts = parse(s,"ps");
unsigned long long puts = parse(s,"pt");
unsigned long long no_mem_puts = parse(s,"px");
unsigned long long dup_puts_flushed = parse(s,"pd");
unsigned long long dup_puts_replaced = parse(s,"pr");
unsigned long long found_gets = parse(s,"gs");
unsigned long long gets = parse(s,"gt");
unsigned long long flushs_found = parse(s,"fs");
unsigned long long flushs = parse(s,"ft");
unsigned long long flush_objs_found = parse(s,"os");
unsigned long long flush_objs = parse(s,"ot");
parse_string(s,"PT",pool_type,2);
parse_sharers(s,"SC",buf,BUFSIZE);
printf("poolid=%lu[%s] uuid=%llx.%llx, shared-by:%s: "
"pgp=%llu(max=%llu) obj=%llu(%llu) "
"objnode=%llu(%llu) puts=%llu/%llu/%llu(dup=%llu/%llu) "
"gets=%llu/%llu(%llu%%) "
"flush=%llu/%llu flobj=%llu/%llu\n",
pool_id, pool_type, uid0, uid1, buf,
pgp_count, max_pgp_count, obj_count, max_obj_count,
objnode_count, max_objnode_count,
good_puts, puts, no_mem_puts,
dup_puts_flushed, dup_puts_replaced,
found_gets, gets,
gets ? (found_gets*100LL)/gets : 0,
flushs_found, flushs, flush_objs_found, flush_objs);
}
static unsigned long __get_uint_hex(const char* s)
{
unsigned long res = 0;
while (*s) {
if (is_hex(*s))
res = (res << 4) + parse_hex(*s);
else if (*s != '_')
break;
s++;
}
return res;
}
/**
* Set node address
* Args: <node-addr>
*/
int cmd_set_uart_speed (int argc, uint8_t **argv) {
if (argc != 2) {
return E_WRONG_ARGC;
}
uint32_t bps = parse_hex(argv[1]);
MyUARTxInit(LPC_USART0, bps);
return E_OK;
}
unsigned char
checksum(char* str)
{
unsigned int i;
unsigned char acum=0;
for(i=0; i < ((strlen(str)-1)/2);i++)
{
acum+=parse_hex(str+1+(i*2),2);
}
return acum;
}
static void validate_message(const char * name, const char * message_string, const char * cmac_string){
mock_clear_packet_buffer();
int len = parse_hex(m, message_string);
// expected result
sm_key_t cmac;
parse_hex(cmac, cmac_string);
printf("-- verify key %s message %s, len %u:\nm: %s\ncmac: %s\n", key_string, name, len, message_string, cmac_string);
sm_key_t key;
parse_hex(key, key_string);
// printf_hexdump(key, 16);
cmac_hash_received = 0;
sm_cmac_general_start(key, len, &get_byte, &cmac_done);
while (!cmac_hash_received){
aes128_report_result();
}
CHECK_EQUAL_ARRAY(cmac, cmac_hash, 16);
}
static int cpn_sign_sk_from_hex(struct cpn_sign_sk *out, const char *hex)
{
if (hex == NULL) {
cpn_log(LOG_LEVEL_ERROR, "Error parsing nonexistent secret signature key");
return -1;
}
if (parse_hex(out->data, sizeof(out->data), hex, strlen(hex)) < 0) {
cpn_log(LOG_LEVEL_ERROR, "Error parsing invalid secret signature key");
return -1;
}
return 0;
}
void UnescapeString(char *str)
{
// fast forward to any escape sequence
while (*str && *str != '\\')
str++;
char *dst = str, *src = str;
while (*src)
{
if (*src == '\\')
{
bool code_found = true;
switch (src[1])
{
case 'a': *dst = '\a'; break;
case 'b': *dst = '\b'; break;
case 'f': *dst = '\f'; break;
case 'n': *dst = '\n'; break;
case 'r': *dst = '\r'; break;
case 't': *dst = '\t'; break;
case 'v': *dst = '\v'; break;
case '0': *dst = '\0'; break;
case '\"': *dst = '\"'; break;
case '\'': *dst = '\''; break;
case '\\': *dst = '\\'; break;
case 'x': // \xXX
case 'u': // \uXXXX
{
// This should be safe. A utf-8 character can be at most 4 bytes,
// and we have 4 bytes to use for \xXX and 6 for \uXXXX.
src += 2;
if (UCS4 hex = parse_hex(src, src[1] == 'x' ? 2 : 4))
dst += utf8::encode(hex, dst);
continue;
}
default:
code_found = false;
}
if (code_found)
{
src += 2;
dst++;
continue;
}
}
*dst = *src;
dst++;
src++;
}
*dst = 0;
}
static void parse_string(query_result r, char* buf)
{
if (r.start < r.end) {
if (*r.start == '"') {
for (const char* p = r.start + 1; p < r.end && *p != '"'; p++) {
char ch = p[0];
if (ch == '\\' && p[1] == 'x' && is_hex(p[2])) {
ch = parse_hex(p[2]);
if (is_hex(p[3])) {
ch = (ch << 4) + parse_hex(p[3]);
p++;
}
p += 2;
}
*buf++ = ch;
}
} else {
for (const char* p = r.start; p < r.end && *p > ' '; p++)
*buf++ = *p;
}
}
*buf = 0;
}
static int I2cWriteReadCommand(int argc, char const ** argv) {
if (argc < 2 || argc > 18) return -1;
uint8_t addr = (uint8_t) parse_hex(argv[0]);
++argv;
--argc;
size_t readlen = (size_t) parse_number(argv[argc - 1]);
--argc;
uint8_t buf[16];
for (int i = 0; i < argc; ++i) {
buf[i] = (uint8_t) parse_hex(argv[i]);
}
if (ERROR_NONE != I2cWriteRead(addr, buf, argc, buf, readlen)) return -3;
for (int i = 0; i < readlen; ++i) {
printf("%02x ", buf[i]);
}
printf("\r\n");
return 0;
}
/**
* Performs a sequence of write actions based on a file input.
* The file input are hexadecimal numbers (given in parse_hex
* compatible format), one per line.
*
* The given file descriptor is closed (even on error).
*/
int perform_file_write(const char *dev, uint32_t addr, uint32_t len, FILE *f)
{
char s_value [S_BUFFSIZE];
uint32_t value;
assert(f != NULL);
struct dtree_dev_t *d = dtree_byname(dev);
if(d == NULL) {
fprintf(stderr, "No device '%s' found\n", dev);
fclose(f);
return 1;
}
while (fgets(s_value, S_BUFFSIZE, f) != NULL) {
size_t s_len = strlen(s_value);
if (s_value[s_len - 1] == '\n') {
s_value[s_len - 1] = '\0';
}
value = parse_hex(s_value, s_len);
verbosity_printf(1, "Action: write, device: '%s', offset: '0x%08X', data: '0x%08X', len: '%d'", dev, addr, value, len);
const dtree_addr_t base = dtree_dev_base(d);
const dtree_addr_t high = dtree_dev_high(d);
if(base < high) {
if(base + addr + len > high) {
verbosity_printf(1, "Address is out of range of the device: 0x%08X (high: 0x%08X)", base + addr, high);
return 2;
}
}
bus_write(base, addr, value, len);
addr += len;
}
dtree_dev_free(d);
fclose(f);
return 0;
}
/*
* Parse the given query string to extract the parameter pname
* and return to the caller. (Not the best way to do it but
* going for simplicity at the moment.)
*/
char *
get_param(char *qstr, const char *pname)
{
if (qstr == NULL)
return NULL;
char *temp;
char *param = NULL;
char *value = NULL;
size_t sz;
while (*qstr) {
sz = strcspn(qstr, "=&");
if (qstr[sz] == '=') {
qstr[sz] = 0;
param = qstr;
}
qstr += sz + 1;
if (param && strcmp(param, pname) == 0)
break;
else
param = NULL;
}
if (param == NULL)
return NULL;
if ((temp = strchr(qstr, '&')) == NULL)
value = strdup(qstr);
else {
sz = temp - qstr;
value = malloc(sz + 1);
if (value == NULL)
errx(EXIT_FAILURE, "malloc failed");
memcpy(value, qstr, sz);
value[sz] = 0;
}
value = parse_space(value);
char *retval = parse_hex(value);
free(value);
return retval;
}
static int cmd_keyboard_id(const char *args)
{
int v = ERR_INVALID_ARGS;
char *t = get_token(args);
if (!t) goto ret;
if (!strcmp(t, "any")) {
current_keyboard_id = 0;
v = 0;
} else {
v = parse_hex(args, 0, 0xffff);
if (v != INVALID_NUMBER) {
current_keyboard_id = (unsigned short)v;
v = 0;
}
}
free(t);
ret:
return v;
}
/* Converts a string with an html entity to it's encoded form, which is written
* to the output string.
*/
static const char *entity_convert(const char *s, char *output, char terminator)
{
/* TODO(falmeida): Handle wide char encodings */
struct entityfilter_table_s *t = entityfilter_table;
if (s[0] == '#') {
if (s[1] == 'x' || s[1] == 'X') { /* hex */
return parse_hex(s + 2, output);
} else { /* decimal */
return parse_dec(s + 1, output);
}
}
while (t->entity != NULL) {
if (strcasecmp(t->entity, s) == 0)
return t->value;
t++;
}
snprintf(output, HTMLPARSER_MAX_ENTITY_SIZE, "&%s%c", s, terminator);
output[HTMLPARSER_MAX_ENTITY_SIZE - 1] = '\0';
return output;
}
int main(int argc, char **argv) {
int trace=0;
char file[512], cryptdata[128];
mf_t trace_mf;
dpa_t *dpa=NULL;
uint8_t hypotheses[1024], key[16], plain[16];
int hypos=0;
correl_t *results=NULL;
time_t start=0, runtime;
int cnt;
int last_cnt=0;
FILE *fl, *ptxts;
float signif;
int best_keybyte=0;
float max_correl=0;
hypo_template_t *hypo_templates;
if(argc<=2) {
printf("see the README\n");
return 0;
}
sscanf(argv[1],"%2s:%d",file,&cnt);
assert((fl=fopen("hypo.txt","w")));
if(!(strcmp(file,"hd"))) {
printf("Hamming-Distance keybyte %d\n",cnt);
fprintf(fl,"sbox_out %d&ff sbox_in %d&ff 0 0\n",cnt,cnt);
}
else if(!(strcmp(file,"hw"))) {
printf("Hamming-Weight keybyte %d\n",cnt);
fprintf(fl,"sbox_out %d&ff null 0&ff 0 0\n",cnt);
}
else {
printf("usage: hd:<keybyte> for hamming dist or hw:<keybyte> for hamming weight\n");
return 0;
}
fclose(fl);
// don't ask...
assert((hypos = hypo_templ_gen("hypo.txt", &hypo_templates, NULL)));
hypos *= 256;
sprintf(file,"%s/aes.log",argv[2]);
assert((ptxts = fopen(file, "r")));
while(fgets(cryptdata, 512, ptxts)) {
if(!(trace%20))
printf("trace %d\n",trace);
assert(parse_hex(cryptdata, plain, 16) == (cryptdata+32));
sprintf(file,"%s/%06d.dat",argv[2],trace);
assert(!(open_trace(&trace_mf, file)));
// generate hypotheses
for(cnt=0; cnt<256; cnt++) {
memset(key, cnt&0xff, 16);
hypo_gen(plain, key, hypo_templates, hypotheses+cnt);
}
if(!dpa) {
dpa = dpa_init(hypos, trace_mf.len);
assert((results = malloc(sizeof(correl_t)*(dpa->tracelen))));
start = time(NULL);
}
dpa_add(dpa, trace_mf.ptr, hypotheses);
trace++;
last_cnt = trace;
signif = 1.3*(4/sqrt((float)trace));
max_correl = 0;
best_keybyte = 0;
if(!(trace%100)) {
for(cnt=0; cnt<hypos; cnt++) {
float max;
dpa_get_results(dpa, cnt, results, &max);
if(ABS(max) > ABS(max_correl)) {
max_correl = max;
best_keybyte = cnt;
}
}
printf("key guess 0x%02x correl: %f (signifcant: >=%f)\n",best_keybyte,max_correl,signif);
}
}
runtime = time(NULL);
runtime -= start;
dpa_speedinfo(dpa, runtime);
// get results
dpa_get_results(dpa, best_keybyte, results, NULL);
assert((fl=fopen("results.txt","w")));
for(cnt=0; cnt < dpa->tracelen; cnt++)
fprintf(fl,"%d: %f\n",cnt,results[cnt]);
fclose(fl);
free(results);
dpa_destroy(&dpa);
return 0;
}
void eepromCLI()
{
uint32_t c1, c2;
uint8_t eepromQuery = 'x';
uint8_t validQuery = false;
cliBusy = true;
cliPortPrint("\nEntering EEPROM CLI....\n\n");
while(true)
{
cliPortPrint("EEPROM CLI -> ");
while ((cliPortAvailable() == false) && (validQuery == false));
if (validQuery == false)
eepromQuery = cliPortRead();
cliPortPrint("\n");
switch(eepromQuery)
{
// 'a' is the standard "print all the information" character
case 'a': // config struct data
c1 = eepromConfig.CRCAtEnd[0];
zeroPIDstates();
c2 = crc32bEEPROM(&eepromConfig, false);
cliPortPrintF("Config structure information:\n");
cliPortPrintF("Version : %d\n", eepromConfig.version );
cliPortPrintF("Size : %d\n", sizeof(eepromConfig) );
cliPortPrintF("CRC on last read : %08X\n", c1 );
cliPortPrintF("Current CRC : %08X\n", c2 );
if ( c1 != c2 )
cliPortPrintF(" CRCs differ. Current Config has not yet been saved.\n");
cliPortPrintF("CRC Flags :\n");
cliPortPrintF(" History Bad : %s\n", eepromConfig.CRCFlags & CRC_HistoryBad ? "true" : "false" );
validQuery = false;
break;
///////////////////////////
case 'c': // Write out to Console in Hex. (RAM -> console)
// we assume the flyer is not in the air, so that this is ok;
// these change randomly when not in flight and can mistakenly
// make one think that the in-memory eeprom struct has changed
zeroPIDstates();
cliPortPrintF("\n");
cliPrintEEPROM(&eepromConfig);
cliPortPrintF("\n");
if (crcCheckVal != crc32bEEPROM(&eepromConfig, true))
{
cliPortPrint("NOTE: in-memory config CRC invalid; there have probably been changes to\n");
cliPortPrint(" eepromConfig since the last write to flash/eeprom.\n");
}
validQuery = false;
break;
///////////////////////////
case 'H': // clear bad history flag
cliPortPrintF("Clearing Bad History flag.\n");
eepromConfig.CRCFlags &= ~CRC_HistoryBad;
validQuery = false;
break;
///////////////////////////
case 'C': // Read in from Console in hex. Console -> RAM
;
uint32_t sz = sizeof(eepromConfig);
eepromConfig_t e;
uint8_t *p = (uint8_t*)&e;
uint8_t *end = (uint8_t*)(&e + 1);
uint32_t t = millis();
enum { Timeout = 100 }; // timeout is in ms
int second_nibble = 0; // 0 or 1
char c;
uint32_t chars_encountered = 0;
cliPortPrintF("Ready to read in config. Expecting %d (0x%03X) bytes as %d\n",
sz, sz, sz * 2);
cliPortPrintF("hexadecimal characters, optionally separated by [ \\n\\r_].\n");
cliPortPrintF("Times out if no character is received for %dms\n", Timeout);
memset(p, 0, end - p);
while (p < end)
{
while (!cliPortAvailable() && millis() - t < Timeout) {}
t = millis();
c = cliPortAvailable() ? cliPortRead() : '\0';
int8_t hex = parse_hex(c);
int ignore = c == ' ' || c == '\n' || c == '\r' || c == '_' ? true : false;
if (c != '\0') // assume the person isn't sending null chars
chars_encountered++;
if (ignore)
continue;
if (hex == -1)
break;
*p |= second_nibble ? hex : hex << 4;
p += second_nibble;
second_nibble ^= 1;
}
if (c == 0)
{
cliPortPrintF("Did not receive enough hex chars! (got %d, expected %d)\n",
(p - (uint8_t*)&e) * 2 + second_nibble, sz * 2);
}
else if (p < end || second_nibble)
{
cliPortPrintF("Invalid character found at position %d: '%c' (0x%02x)",
chars_encountered, c, c);
}
// HJI else if (crcCheckVal != crc32bEEPROM(&e, true))
// HJI {
// HJI cliPortPrintF("CRC mismatch! Not writing to in-memory config.\n");
// HJI cliPortPrintF("Here's what was received:\n\n");
// HJI cliPrintEEPROM(&e);
// HJI }
else
{
// check to see if the newly received eeprom config
// actually differs from what's in-memory
zeroPIDstates();
int i;
for (i = 0; i < sz; i++)
if (((uint8_t*)&e)[i] != ((uint8_t*)&eepromConfig)[i])
break;
if (i == sz)
{
cliPortPrintF("NOTE: uploaded config was identical to in-memory config.\n");
}
else
{
eepromConfig = e;
cliPortPrintF("In-memory config updated!\n");
cliPortPrintF("NOTE: config not written to EEPROM; use 'W' to do so.\n");
}
}
// eat the next 100ms (or whatever Timeout is) of characters,
// in case the person pasted too much by mistake or something
t = millis();
while (millis() - t < Timeout)
if (cliPortAvailable())
cliPortRead();
validQuery = false;
break;
///////////////////////////
case 'E': // Read in from EEPROM. (EEPROM -> RAM)
cliPortPrint("Re-reading EEPROM.\n");
readEEPROM();
validQuery = false;
break;
///////////////////////////
case 'x': // exit EEPROM CLI
cliPortPrint("\nExiting EEPROM CLI....\n\n");
cliBusy = false;
return;
break;
///////////////////////////
case 'W':
case 'e': // Write out to EEPROM. (RAM -> EEPROM)
cliPortPrint("\nWriting EEPROM Parameters....\n\n");
validQuery = false;
writeEEPROM();
break;
///////////////////////////
case 'f': // Write out to sdCard FILE. (RAM -> FILE)
validQuery = false;
break;
///////////////////////////
case 'F': // Read in from sdCard FILE. (FILE -> RAM)
validQuery = false;
break;
///////////////////////////
case 'V': // Reset EEPROM Parameters
cliPortPrint( "\nEEPROM Parameters Reset....(not rebooting)\n" );
checkFirstTime(true);
validQuery = false;
break;
///////////////////////////
case '?':
// 0 1 2 3 4 5 6 7
// 01234567890123456789012345678901234567890123456789012345678901234567890123456789
cliPortPrintF("\n");
cliPortPrintF("'a' Display in-RAM config information\n");
cliPortPrintF("'c' Write in-RAM -> Console (as Hex) 'C' Read Console (as Hex) -> in-RAM\n");
cliPortPrintF("'e' Write in-RAM -> EEPROM 'E' Read EEPROM -> in-RAM\n");
cliPortPrintF("'f' Write in-RAM -> sd FILE (Not yet imp) 'F' Read sd FILE -> in-RAM (Not imp)\n");
cliPortPrintF(" 'H' Clear CRC Bad History flag\n");
cliPortPrintF(" 'V' Reset in-RAM config to default.\n");
cliPortPrintF("'x' Exit EEPROM CLI '?' Command Summary\n");
cliPortPrintF("\n");
cliPortPrintF("For compatability: 'W' Write in-RAM -> EEPROM\n");
cliPortPrintF("\n");
break;
///////////////////////////
}
}
}
int
read_ihx(_pic * pic,const char * fname, int leeprom)
{
FILE* fin;
int lc=0;
unsigned int bc;
char line[256];
unsigned int nbytes,addr,type;
unsigned int addrx;
unsigned short addrh=0;
unsigned short addrl=0;
char *mptr;
fin=fopen(fname,"r");
if(fin)
{
do
{
fgets(line,256,fin);
lc++;
/*for dos file*/
if(line[strlen(line)-2]=='\r')
{
line[strlen(line)-2]='\n';
line[strlen(line)-1]=0;
}
if(checksum(line) == 0)
{
nbytes=parse_hex(line+1,2);
addr=parse_hex(line+3,4);
type=parse_hex(line+7,2);
switch(type)
{
case 0:
addrl=addr/2;
if((((addrh<<16)|addrl)<<1) == 0x400E )
{
//config
mptr=(char*)pic->config;
for(bc=0;bc < nbytes;bc++)
{
addrx=((addrh<<16)|addr)+bc-0x400E;
if((addrx/2) < pic->CONFIGSIZE)
mptr[addrx]=parse_hex(line+9+(bc*2),2);
}
}
else
{
if((((addrh<<16)|addrl)<<1) >= 0x4200 )
{
//EEPROM
if(leeprom == 1)
for(bc=0;bc < nbytes;bc+=2)
{
addrx= (((addrh<<16)|addr)+bc-0x4200)/2;
if(addrx < pic->EEPROMSIZE*2)
pic->eeprom[addrx]=parse_hex(line+9+(bc*2),2);
}
}
else
{
if((((addrh<<16)|addrl)<<1) >= 0x4000 )
{
//IDS
mptr=(char*)pic->id;
for(bc=0;bc < nbytes;bc++)
{
addrx=((addrh<<16)|addr)+bc-0x4000;
if((addrx/2) < pic->IDSIZE)
mptr[addrx]=parse_hex(line+9+(bc*2),2);
}
}
else
{
//prog mem
mptr=(char*)pic->prog;
for(bc=0;bc < nbytes;bc++)
{
addrx=((addrh<<16)|addr)+bc;
if((addrx/2) < pic->ROMSIZE)
mptr[addrx]=parse_hex(line+9+(bc*2),2);
}
}
}
}
break;
case 1:
fclose(fin);
return 0;//no error
break;
case 4:
addrh=((parse_hex(line+9,2)<<8)|parse_hex(line+11,2));
break;
}
}
else
{
printf("ERRO: Picsim->File bad checksum line %i!(%s)\n",lc,fname);
fclose(fin);
return HEX_CHKSUM;
}
}
while(!feof(fin));
fclose(fin);
}
else
{
printf("ERRO: Picsim->File not found!(%s)\n",fname);
return HEX_NFOUND;
}
return 0;//no error
};
