|
|
@ -19,6 +19,163 @@ |
|
|
|
#include <memory.h> |
|
|
|
#include "cJSON.c" |
|
|
|
|
|
|
|
|
|
|
|
char hexbyte(int32_t c) |
|
|
|
{ |
|
|
|
c &= 0xf; |
|
|
|
if ( c < 10 ) |
|
|
|
return('0'+c); |
|
|
|
else if ( c < 16 ) |
|
|
|
return('a'+c-10); |
|
|
|
else return(0); |
|
|
|
} |
|
|
|
|
|
|
|
int32_t _unhex(char c) |
|
|
|
{ |
|
|
|
if ( c >= '0' && c <= '9' ) |
|
|
|
return(c - '0'); |
|
|
|
else if ( c >= 'a' && c <= 'f' ) |
|
|
|
return(c - 'a' + 10); |
|
|
|
else if ( c >= 'A' && c <= 'F' ) |
|
|
|
return(c - 'A' + 10); |
|
|
|
return(-1); |
|
|
|
} |
|
|
|
|
|
|
|
int32_t is_hexstr(char *str,int32_t n) |
|
|
|
{ |
|
|
|
int32_t i; |
|
|
|
if ( str == 0 || str[0] == 0 ) |
|
|
|
return(0); |
|
|
|
for (i=0; str[i]!=0; i++) |
|
|
|
{ |
|
|
|
if ( n > 0 && i >= n ) |
|
|
|
break; |
|
|
|
if ( _unhex(str[i]) < 0 ) |
|
|
|
break; |
|
|
|
} |
|
|
|
if ( n == 0 ) |
|
|
|
return(i); |
|
|
|
return(i == n); |
|
|
|
} |
|
|
|
|
|
|
|
int32_t unhex(char c) |
|
|
|
{ |
|
|
|
int32_t hex; |
|
|
|
if ( (hex= _unhex(c)) < 0 ) |
|
|
|
{ |
|
|
|
//printf("unhex: illegal hexchar.(%c)\n",c);
|
|
|
|
} |
|
|
|
return(hex); |
|
|
|
} |
|
|
|
|
|
|
|
unsigned char _decode_hex(char *hex) { return((unhex(hex[0])<<4) | unhex(hex[1])); } |
|
|
|
|
|
|
|
int32_t decode_hex(unsigned char *bytes,int32_t n,char *hex) |
|
|
|
{ |
|
|
|
int32_t adjust,i = 0; |
|
|
|
//printf("decode.(%s)\n",hex);
|
|
|
|
if ( is_hexstr(hex,n) <= 0 ) |
|
|
|
{ |
|
|
|
memset(bytes,0,n); |
|
|
|
return(n); |
|
|
|
} |
|
|
|
if ( hex[n-1] == '\n' || hex[n-1] == '\r' ) |
|
|
|
hex[--n] = 0; |
|
|
|
if ( hex[n-1] == '\n' || hex[n-1] == '\r' ) |
|
|
|
hex[--n] = 0; |
|
|
|
if ( n == 0 || (hex[n*2+1] == 0 && hex[n*2] != 0) ) |
|
|
|
{ |
|
|
|
if ( n > 0 ) |
|
|
|
{ |
|
|
|
bytes[0] = unhex(hex[0]); |
|
|
|
printf("decode_hex n.%d hex[0] (%c) -> %d hex.(%s) [n*2+1: %d] [n*2: %d %c] len.%ld\n",n,hex[0],bytes[0],hex,hex[n*2+1],hex[n*2],hex[n*2],(long)strlen(hex)); |
|
|
|
} |
|
|
|
bytes++; |
|
|
|
hex++; |
|
|
|
adjust = 1; |
|
|
|
} else adjust = 0; |
|
|
|
if ( n > 0 ) |
|
|
|
{ |
|
|
|
for (i=0; i<n; i++) |
|
|
|
bytes[i] = _decode_hex(&hex[i*2]); |
|
|
|
} |
|
|
|
//bytes[i] = 0;
|
|
|
|
return(n + adjust); |
|
|
|
} |
|
|
|
|
|
|
|
int32_t init_hexbytes_noT(char *hexbytes,unsigned char *message,long len) |
|
|
|
{ |
|
|
|
int32_t i; |
|
|
|
if ( len <= 0 ) |
|
|
|
{ |
|
|
|
hexbytes[0] = 0; |
|
|
|
return(1); |
|
|
|
} |
|
|
|
for (i=0; i<len; i++) |
|
|
|
{ |
|
|
|
hexbytes[i*2] = hexbyte((message[i]>>4) & 0xf); |
|
|
|
hexbytes[i*2 + 1] = hexbyte(message[i] & 0xf); |
|
|
|
//printf("i.%d (%02x) [%c%c]\n",i,message[i],hexbytes[i*2],hexbytes[i*2+1]);
|
|
|
|
} |
|
|
|
hexbytes[len*2] = 0; |
|
|
|
//printf("len.%ld\n",len*2+1);
|
|
|
|
return((int32_t)len*2+1); |
|
|
|
} |
|
|
|
|
|
|
|
long _stripwhite(char *buf,int accept) |
|
|
|
{ |
|
|
|
int32_t i,j,c; |
|
|
|
if ( buf == 0 || buf[0] == 0 ) |
|
|
|
return(0); |
|
|
|
for (i=j=0; buf[i]!=0; i++) |
|
|
|
{ |
|
|
|
buf[j] = c = buf[i]; |
|
|
|
if ( c == accept || (c != ' ' && c != '\n' && c != '\r' && c != '\t' && c != '\b') ) |
|
|
|
j++; |
|
|
|
} |
|
|
|
buf[j] = 0; |
|
|
|
return(j); |
|
|
|
} |
|
|
|
|
|
|
|
char *clonestr(char *str) |
|
|
|
{ |
|
|
|
char *clone; |
|
|
|
if ( str == 0 || str[0] == 0 ) |
|
|
|
{ |
|
|
|
printf("warning cloning nullstr.%p\n",str); |
|
|
|
//#ifdef __APPLE__
|
|
|
|
// while ( 1 ) sleep(1);
|
|
|
|
//#endif
|
|
|
|
str = (char *)"<nullstr>"; |
|
|
|
} |
|
|
|
clone = (char *)malloc(strlen(str)+16); |
|
|
|
strcpy(clone,str); |
|
|
|
return(clone); |
|
|
|
} |
|
|
|
|
|
|
|
int32_t safecopy(char *dest,char *src,long len) |
|
|
|
{ |
|
|
|
int32_t i = -1; |
|
|
|
if ( src != 0 && dest != 0 && src != dest ) |
|
|
|
{ |
|
|
|
if ( dest != 0 ) |
|
|
|
memset(dest,0,len); |
|
|
|
for (i=0; i<len&&src[i]!=0; i++) |
|
|
|
dest[i] = src[i]; |
|
|
|
if ( i == len ) |
|
|
|
{ |
|
|
|
printf("safecopy: %s too long %ld\n",src,len); |
|
|
|
//printf("divide by zero! %d\n",1/zeroval());
|
|
|
|
#ifdef __APPLE__ |
|
|
|
//getchar();
|
|
|
|
#endif |
|
|
|
return(-1); |
|
|
|
} |
|
|
|
dest[i] = 0; |
|
|
|
} |
|
|
|
return(i); |
|
|
|
} |
|
|
|
|
|
|
|
char *nonportable_path(char *str) |
|
|
|
{ |
|
|
|
int32_t i; |
|
|
|