mirror of
https://github.com/RfidResearchGroup/proxmark3.git
synced 2025-08-14 02:27:26 -07:00
make style
This commit is contained in:
Philippe Teuwen
parent
0d9223a547
commit
0373696662
483 changed files with 56514 additions and 52451 deletions
330
client/util.c
330
client/util.c
|
|
@ -25,12 +25,13 @@ uint8_t g_debugMode = 0;
|
|||
#include <unistd.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
int ukbhit(void) {
|
||||
int ukbhit(void)
|
||||
{
|
||||
int cnt = 0;
|
||||
int error;
|
||||
static struct termios Otty, Ntty;
|
||||
|
||||
if ( tcgetattr(STDIN_FILENO, &Otty) == -1) return -1;
|
||||
if (tcgetattr(STDIN_FILENO, &Otty) == -1) return -1;
|
||||
|
||||
Ntty = Otty;
|
||||
|
||||
|
|
@ -44,13 +45,14 @@ int ukbhit(void) {
|
|||
error += ioctl(STDIN_FILENO, FIONREAD, &cnt); // get number of characters available
|
||||
error += tcsetattr(STDIN_FILENO, TCSANOW, &Otty); // reset attributes
|
||||
}
|
||||
return ( error == 0 ? cnt : -1 );
|
||||
return (error == 0 ? cnt : -1);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#include <conio.h>
|
||||
int ukbhit(void) {
|
||||
int ukbhit(void)
|
||||
{
|
||||
return kbhit();
|
||||
}
|
||||
#endif
|
||||
|
|
@ -58,7 +60,8 @@ int ukbhit(void) {
|
|||
// log files functions
|
||||
|
||||
// open, appped and close logfile
|
||||
void AddLogLine(char *fn, char *data, char *c) {
|
||||
void AddLogLine(char *fn, char *data, char *c)
|
||||
{
|
||||
FILE *f = NULL;
|
||||
char filename[FILE_PATH_SIZE] = {0x00};
|
||||
int len = 0;
|
||||
|
|
@ -80,24 +83,27 @@ void AddLogLine(char *fn, char *data, char *c) {
|
|||
fclose(f);
|
||||
}
|
||||
|
||||
void AddLogHex(char *fn, char *extData, const uint8_t * data, const size_t len){
|
||||
void AddLogHex(char *fn, char *extData, const uint8_t *data, const size_t len)
|
||||
{
|
||||
AddLogLine(fn, extData, sprint_hex(data, len));
|
||||
}
|
||||
|
||||
void AddLogUint64(char *fn, char *data, const uint64_t value) {
|
||||
void AddLogUint64(char *fn, char *data, const uint64_t value)
|
||||
{
|
||||
char buf[20] = {0};
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
sprintf(buf, "%016" PRIx64 "", value);
|
||||
AddLogLine(fn, data, buf);
|
||||
}
|
||||
|
||||
void AddLogCurrentDT(char *fn) {
|
||||
void AddLogCurrentDT(char *fn)
|
||||
{
|
||||
char buf[20];
|
||||
memset(buf, 0x00, sizeof(buf));
|
||||
struct tm *curTime;
|
||||
time_t now = time(0);
|
||||
curTime = gmtime(&now);
|
||||
strftime (buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", curTime);
|
||||
strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", curTime);
|
||||
AddLogLine(fn, "\nanticollision: ", buf);
|
||||
}
|
||||
|
||||
|
|
@ -106,8 +112,9 @@ void AddLogCurrentDT(char *fn) {
|
|||
// param *uid - pointer to uid byte array
|
||||
// param *ext - ".log"
|
||||
// param uidlen - length of uid array.
|
||||
void FillFileNameByUID(char *filenamePrefix, uint8_t *uid, const char *ext, int uidlen) {
|
||||
if ( filenamePrefix == NULL || uid == NULL || ext == NULL ){
|
||||
void FillFileNameByUID(char *filenamePrefix, uint8_t *uid, const char *ext, int uidlen)
|
||||
{
|
||||
if (filenamePrefix == NULL || uid == NULL || ext == NULL) {
|
||||
printf("[!] error parameter is NULL\n");
|
||||
return;
|
||||
}
|
||||
|
|
@ -122,14 +129,15 @@ void FillFileNameByUID(char *filenamePrefix, uint8_t *uid, const char *ext, int
|
|||
}
|
||||
|
||||
// fill buffer from structure [{uint8_t data, size_t length},...]
|
||||
int FillBuffer(uint8_t *data, size_t maxDataLength, size_t *dataLength, ...) {
|
||||
int FillBuffer(uint8_t *data, size_t maxDataLength, size_t *dataLength, ...)
|
||||
{
|
||||
*dataLength = 0;
|
||||
va_list valist;
|
||||
va_start(valist, dataLength);
|
||||
|
||||
uint8_t *vdata = NULL;
|
||||
size_t vlength = 0;
|
||||
do{
|
||||
do {
|
||||
vdata = va_arg(valist, uint8_t *);
|
||||
if (!vdata)
|
||||
break;
|
||||
|
|
@ -150,7 +158,8 @@ int FillBuffer(uint8_t *data, size_t maxDataLength, size_t *dataLength, ...) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
bool CheckStringIsHEXValue(const char *value) {
|
||||
bool CheckStringIsHEXValue(const char *value)
|
||||
{
|
||||
for (int i = 0; i < strlen(value); i++)
|
||||
if (!isxdigit(value[i]))
|
||||
return false;
|
||||
|
|
@ -162,13 +171,14 @@ bool CheckStringIsHEXValue(const char *value) {
|
|||
}
|
||||
|
||||
void hex_to_buffer(const uint8_t *buf, const uint8_t *hex_data, const size_t hex_len, const size_t hex_max_len,
|
||||
const size_t min_str_len, const size_t spaces_between, bool uppercase) {
|
||||
const size_t min_str_len, const size_t spaces_between, bool uppercase)
|
||||
{
|
||||
|
||||
char *tmp = (char *)buf;
|
||||
size_t i;
|
||||
memset(tmp, 0x00, hex_max_len);
|
||||
|
||||
int maxLen = ( hex_len > hex_max_len) ? hex_max_len : hex_len;
|
||||
int maxLen = (hex_len > hex_max_len) ? hex_max_len : hex_len;
|
||||
|
||||
for (i = 0; i < maxLen; ++i, tmp += 2 + spaces_between) {
|
||||
sprintf(tmp, (uppercase) ? "%02X" : "%02x", (unsigned int) hex_data[i]);
|
||||
|
|
@ -181,21 +191,23 @@ void hex_to_buffer(const uint8_t *buf, const uint8_t *hex_data, const size_t hex
|
|||
int minStrLen = min_str_len > i ? min_str_len : 0;
|
||||
if (minStrLen > hex_max_len)
|
||||
minStrLen = hex_max_len;
|
||||
for(; i < minStrLen; i++, tmp += 1)
|
||||
for (; i < minStrLen; i++, tmp += 1)
|
||||
sprintf(tmp, " ");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// printing and converting functions
|
||||
void print_hex(const uint8_t *data, const size_t len) {
|
||||
void print_hex(const uint8_t *data, const size_t len)
|
||||
{
|
||||
size_t i;
|
||||
for (i=0; i < len; i++)
|
||||
for (i = 0; i < len; i++)
|
||||
printf("%02x ", data[i]);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
void print_hex_break(const uint8_t *data, const size_t len, uint8_t breaks) {
|
||||
void print_hex_break(const uint8_t *data, const size_t len, uint8_t breaks)
|
||||
{
|
||||
int rownum = 0;
|
||||
printf("[%02d] | ", rownum);
|
||||
for (int i = 0; i < len; ++i) {
|
||||
|
|
@ -203,7 +215,7 @@ void print_hex_break(const uint8_t *data, const size_t len, uint8_t breaks) {
|
|||
printf("%02X ", data[i]);
|
||||
|
||||
// check if a line break is needed
|
||||
if ( breaks > 0 && !((i+1) % breaks) && (i+1 < len) ) {
|
||||
if (breaks > 0 && !((i + 1) % breaks) && (i + 1 < len)) {
|
||||
++rownum;
|
||||
printf("\n[%02d] | ", rownum);
|
||||
}
|
||||
|
|
@ -211,36 +223,41 @@ void print_hex_break(const uint8_t *data, const size_t len, uint8_t breaks) {
|
|||
printf("\n");
|
||||
}
|
||||
|
||||
char *sprint_hex(const uint8_t *data, const size_t len) {
|
||||
char *sprint_hex(const uint8_t *data, const size_t len)
|
||||
{
|
||||
static char buf[UTIL_BUFFER_SIZE_SPRINT - 3] = {0};
|
||||
hex_to_buffer((uint8_t *)buf, data, len, sizeof(buf) - 1, 0, 1, true);
|
||||
return buf;
|
||||
}
|
||||
|
||||
char *sprint_hex_inrow_ex(const uint8_t *data, const size_t len, const size_t min_str_len) {
|
||||
char *sprint_hex_inrow_ex(const uint8_t *data, const size_t len, const size_t min_str_len)
|
||||
{
|
||||
static char buf[UTIL_BUFFER_SIZE_SPRINT] = {0};
|
||||
hex_to_buffer((uint8_t *)buf, data, len, sizeof(buf) - 1, min_str_len, 0, true);
|
||||
return buf;
|
||||
}
|
||||
|
||||
char *sprint_hex_inrow(const uint8_t *data, const size_t len) {
|
||||
char *sprint_hex_inrow(const uint8_t *data, const size_t len)
|
||||
{
|
||||
return sprint_hex_inrow_ex(data, len, 0);
|
||||
}
|
||||
char *sprint_hex_inrow_spaces(const uint8_t *data, const size_t len, size_t spaces_between) {
|
||||
char *sprint_hex_inrow_spaces(const uint8_t *data, const size_t len, size_t spaces_between)
|
||||
{
|
||||
static char buf[UTIL_BUFFER_SIZE_SPRINT] = {0};
|
||||
hex_to_buffer((uint8_t *)buf, data, len, sizeof(buf) - 1, 0, spaces_between, true);
|
||||
return buf;
|
||||
}
|
||||
|
||||
char *sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t breaks) {
|
||||
char *sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t breaks)
|
||||
{
|
||||
|
||||
// make sure we don't go beyond our char array memory
|
||||
size_t in_index = 0, out_index = 0;
|
||||
|
||||
int rowlen = (len > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len;
|
||||
int rowlen = (len > MAX_BIN_BREAK_LENGTH) ? MAX_BIN_BREAK_LENGTH : len;
|
||||
|
||||
if ( breaks > 0 && len % breaks != 0)
|
||||
rowlen = ( len+(len/breaks) > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len+(len/breaks);
|
||||
if (breaks > 0 && len % breaks != 0)
|
||||
rowlen = (len + (len / breaks) > MAX_BIN_BREAK_LENGTH) ? MAX_BIN_BREAK_LENGTH : len + (len / breaks);
|
||||
|
||||
//printf("(sprint_bin_break) rowlen %d\n", rowlen);
|
||||
|
||||
|
|
@ -250,14 +267,14 @@ char *sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t brea
|
|||
char *tmp = buf;
|
||||
|
||||
// loop through the out_index to make sure we don't go too far
|
||||
for (out_index=0; out_index < rowlen; out_index++) {
|
||||
for (out_index = 0; out_index < rowlen; out_index++) {
|
||||
// set character
|
||||
sprintf(tmp++, "%u", data[in_index]);
|
||||
// check if a line break is needed and we have room to print it in our array
|
||||
if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 != rowlen) ) {
|
||||
if ((breaks > 0) && !((in_index + 1) % breaks) && (out_index + 1 != rowlen)) {
|
||||
// increment and print line break
|
||||
out_index++;
|
||||
sprintf(tmp++, "%s","\n");
|
||||
sprintf(tmp++, "%s", "\n");
|
||||
}
|
||||
in_index++;
|
||||
}
|
||||
|
|
@ -303,72 +320,79 @@ void sprint_bin_break_ex(uint8_t *src, size_t srclen, char *dest , uint8_t break
|
|||
}
|
||||
*/
|
||||
|
||||
char *sprint_bin(const uint8_t *data, const size_t len) {
|
||||
char *sprint_bin(const uint8_t *data, const size_t len)
|
||||
{
|
||||
return sprint_bin_break(data, len, 0);
|
||||
}
|
||||
|
||||
char *sprint_hex_ascii(const uint8_t *data, const size_t len) {
|
||||
char *sprint_hex_ascii(const uint8_t *data, const size_t len)
|
||||
{
|
||||
static char buf[UTIL_BUFFER_SIZE_SPRINT];
|
||||
char *tmp = buf;
|
||||
memset(buf, 0x00, UTIL_BUFFER_SIZE_SPRINT);
|
||||
size_t max_len = (len > 1010) ? 1010 : len;
|
||||
|
||||
snprintf(tmp, UTIL_BUFFER_SIZE_SPRINT, "%s| ", sprint_hex(data, max_len) );
|
||||
snprintf(tmp, UTIL_BUFFER_SIZE_SPRINT, "%s| ", sprint_hex(data, max_len));
|
||||
|
||||
size_t i = 0;
|
||||
size_t pos = (max_len * 3) + 2;
|
||||
while (i < max_len){
|
||||
while (i < max_len) {
|
||||
char c = data[i];
|
||||
if ( (c < 32) || (c == 127))
|
||||
if ((c < 32) || (c == 127))
|
||||
c = '.';
|
||||
sprintf(tmp+pos+i, "%c", c);
|
||||
sprintf(tmp + pos + i, "%c", c);
|
||||
++i;
|
||||
}
|
||||
return buf;
|
||||
}
|
||||
|
||||
char *sprint_ascii_ex(const uint8_t *data, const size_t len, const size_t min_str_len) {
|
||||
char *sprint_ascii_ex(const uint8_t *data, const size_t len, const size_t min_str_len)
|
||||
{
|
||||
static char buf[UTIL_BUFFER_SIZE_SPRINT];
|
||||
char *tmp = buf;
|
||||
memset(buf, 0x00, UTIL_BUFFER_SIZE_SPRINT);
|
||||
size_t max_len = (len > 1010) ? 1010 : len;
|
||||
size_t i = 0;
|
||||
while(i < max_len){
|
||||
while (i < max_len) {
|
||||
char c = data[i];
|
||||
tmp[i] = ((c < 32) || (c == 127)) ? '.' : c;
|
||||
++i;
|
||||
}
|
||||
|
||||
int m = min_str_len > i ? min_str_len : 0;
|
||||
for(; i < m; ++i)
|
||||
for (; i < m; ++i)
|
||||
tmp[i] = ' ';
|
||||
|
||||
return buf;
|
||||
}
|
||||
char *sprint_ascii(const uint8_t *data, const size_t len) {
|
||||
char *sprint_ascii(const uint8_t *data, const size_t len)
|
||||
{
|
||||
return sprint_ascii_ex(data, len, 0);
|
||||
}
|
||||
|
||||
void print_blocks(uint32_t *data, size_t len) {
|
||||
void print_blocks(uint32_t *data, size_t len)
|
||||
{
|
||||
PrintAndLogEx(NORMAL, "Blk | Data ");
|
||||
PrintAndLogEx(NORMAL, "----+------------");
|
||||
|
||||
if ( !data ) {
|
||||
if (!data) {
|
||||
PrintAndLogEx(ERR, "..empty data");
|
||||
} else {
|
||||
for (uint8_t i=0; i<len; i++)
|
||||
for (uint8_t i = 0; i < len; i++)
|
||||
PrintAndLogEx(NORMAL, "%02d | 0x%08X", i, data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void num_to_bytes(uint64_t n, size_t len, uint8_t* dest) {
|
||||
void num_to_bytes(uint64_t n, size_t len, uint8_t *dest)
|
||||
{
|
||||
while (len--) {
|
||||
dest[len] = n & 0xFF;
|
||||
n >>= 8;
|
||||
}
|
||||
}
|
||||
|
||||
uint64_t bytes_to_num(uint8_t* src, size_t len) {
|
||||
uint64_t bytes_to_num(uint8_t *src, size_t len)
|
||||
{
|
||||
uint64_t num = 0;
|
||||
while (len--) {
|
||||
num = (num << 8) | (*src);
|
||||
|
|
@ -378,7 +402,8 @@ uint64_t bytes_to_num(uint8_t* src, size_t len) {
|
|||
}
|
||||
|
||||
// takes a number (uint64_t) and creates a binarray in dest.
|
||||
void num_to_bytebits(uint64_t n, size_t len, uint8_t *dest) {
|
||||
void num_to_bytebits(uint64_t n, size_t len, uint8_t *dest)
|
||||
{
|
||||
while (len--) {
|
||||
dest[len] = n & 1;
|
||||
n >>= 1;
|
||||
|
|
@ -386,8 +411,9 @@ void num_to_bytebits(uint64_t n, size_t len, uint8_t *dest) {
|
|||
}
|
||||
|
||||
//least significant bit first
|
||||
void num_to_bytebitsLSBF(uint64_t n, size_t len, uint8_t *dest) {
|
||||
for(int i = 0 ; i < len ; ++i) {
|
||||
void num_to_bytebitsLSBF(uint64_t n, size_t len, uint8_t *dest)
|
||||
{
|
||||
for (int i = 0 ; i < len ; ++i) {
|
||||
dest[i] = n & 1;
|
||||
n >>= 1;
|
||||
}
|
||||
|
|
@ -397,13 +423,14 @@ void num_to_bytebitsLSBF(uint64_t n, size_t len, uint8_t *dest) {
|
|||
// to
|
||||
// hh,gg,ff,ee,dd,cc,bb,aa, pp,oo,nn,mm,ll,kk,jj,ii
|
||||
// up to 64 bytes or 512 bits
|
||||
uint8_t *SwapEndian64(const uint8_t *src, const size_t len, const uint8_t blockSize){
|
||||
uint8_t *SwapEndian64(const uint8_t *src, const size_t len, const uint8_t blockSize)
|
||||
{
|
||||
static uint8_t buf[64];
|
||||
memset(buf, 0x00, 64);
|
||||
uint8_t *tmp = buf;
|
||||
for (uint8_t block=0; block < (uint8_t)(len/blockSize); block++){
|
||||
for (size_t i = 0; i < blockSize; i++){
|
||||
tmp[i+(blockSize*block)] = src[(blockSize-1-i)+(blockSize*block)];
|
||||
for (uint8_t block = 0; block < (uint8_t)(len / blockSize); block++) {
|
||||
for (size_t i = 0; i < blockSize; i++) {
|
||||
tmp[i + (blockSize * block)] = src[(blockSize - 1 - i) + (blockSize * block)];
|
||||
}
|
||||
}
|
||||
return buf;
|
||||
|
|
@ -411,10 +438,11 @@ uint8_t *SwapEndian64(const uint8_t *src, const size_t len, const uint8_t blockS
|
|||
|
||||
// takes a uint8_t src array, for len items and reverses the byte order in blocksizes (8,16,32,64),
|
||||
// returns: the dest array contains the reordered src array.
|
||||
void SwapEndian64ex(const uint8_t *src, const size_t len, const uint8_t blockSize, uint8_t *dest){
|
||||
for (uint8_t block=0; block < (uint8_t)(len/blockSize); block++){
|
||||
for (size_t i = 0; i < blockSize; i++){
|
||||
dest[i+(blockSize*block)] = src[(blockSize-1-i)+(blockSize*block)];
|
||||
void SwapEndian64ex(const uint8_t *src, const size_t len, const uint8_t blockSize, uint8_t *dest)
|
||||
{
|
||||
for (uint8_t block = 0; block < (uint8_t)(len / blockSize); block++) {
|
||||
for (size_t i = 0; i < blockSize; i++) {
|
||||
dest[i + (blockSize * block)] = src[(blockSize - 1 - i) + (blockSize * block)];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -436,21 +464,21 @@ int param_getptr(const char *line, int *bg, int *en, int paramnum)
|
|||
*bg = 0;
|
||||
*en = 0;
|
||||
|
||||
// skip spaces
|
||||
while (line[*bg] ==' ' || line[*bg]=='\t') (*bg)++;
|
||||
// skip spaces
|
||||
while (line[*bg] == ' ' || line[*bg] == '\t')(*bg)++;
|
||||
if (*bg >= len) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (i = 0; i < paramnum; i++) {
|
||||
while (line[*bg]!=' ' && line[*bg]!='\t' && line[*bg] != '\0') (*bg)++;
|
||||
while (line[*bg]==' ' || line[*bg]=='\t') (*bg)++;
|
||||
while (line[*bg] != ' ' && line[*bg] != '\t' && line[*bg] != '\0')(*bg)++;
|
||||
while (line[*bg] == ' ' || line[*bg] == '\t')(*bg)++;
|
||||
|
||||
if (line[*bg] == '\0') return 1;
|
||||
}
|
||||
|
||||
*en = *bg;
|
||||
while (line[*en] != ' ' && line[*en] != '\t' && line[*en] != '\0') (*en)++;
|
||||
while (line[*en] != ' ' && line[*en] != '\t' && line[*en] != '\0')(*en)++;
|
||||
|
||||
(*en)--;
|
||||
|
||||
|
|
@ -466,11 +494,13 @@ int param_getlength(const char *line, int paramnum)
|
|||
return en - bg + 1;
|
||||
}
|
||||
|
||||
char param_getchar(const char *line, int paramnum) {
|
||||
char param_getchar(const char *line, int paramnum)
|
||||
{
|
||||
return param_getchar_indx(line, 0, paramnum);
|
||||
}
|
||||
|
||||
char param_getchar_indx(const char *line, int indx, int paramnum) {
|
||||
char param_getchar_indx(const char *line, int indx, int paramnum)
|
||||
{
|
||||
int bg, en;
|
||||
|
||||
if (param_getptr(line, &bg, &en, paramnum)) return 0x00;
|
||||
|
|
@ -495,7 +525,7 @@ uint8_t param_get8(const char *line, int paramnum)
|
|||
uint8_t param_getdec(const char *line, int paramnum, uint8_t *destination)
|
||||
{
|
||||
uint8_t val = param_get8ex(line, paramnum, 255, 10);
|
||||
if( (int8_t) val == -1) return 1;
|
||||
if ((int8_t) val == -1) return 1;
|
||||
(*destination) = val;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -510,7 +540,7 @@ uint8_t param_isdec(const char *line, int paramnum)
|
|||
int bg, en;
|
||||
//TODO, check more thorougly
|
||||
if (!param_getptr(line, &bg, &en, paramnum)) return 1;
|
||||
// return strtoul(&line[bg], NULL, 10) & 0xff;
|
||||
// return strtoul(&line[bg], NULL, 10) & 0xff;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -542,7 +572,8 @@ uint64_t param_get64ex(const char *line, int paramnum, int deflt, int base)
|
|||
return deflt;
|
||||
}
|
||||
|
||||
int param_gethex(const char *line, int paramnum, uint8_t * data, int hexcnt) {
|
||||
int param_gethex(const char *line, int paramnum, uint8_t *data, int hexcnt)
|
||||
{
|
||||
int bg, en, i;
|
||||
uint32_t temp;
|
||||
|
||||
|
|
@ -552,16 +583,17 @@ int param_gethex(const char *line, int paramnum, uint8_t * data, int hexcnt) {
|
|||
|
||||
if (en - bg + 1 != hexcnt) return 1;
|
||||
|
||||
for(i = 0; i < hexcnt; i += 2) {
|
||||
if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1])) ) return 1;
|
||||
for (i = 0; i < hexcnt; i += 2) {
|
||||
if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1]))) return 1;
|
||||
|
||||
sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
|
||||
sscanf((char[]) {line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
|
||||
data[i / 2] = temp & 0xff;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
int param_gethex_ex(const char *line, int paramnum, uint8_t * data, int *hexcnt) {
|
||||
int param_gethex_ex(const char *line, int paramnum, uint8_t *data, int *hexcnt)
|
||||
{
|
||||
int bg, en, i;
|
||||
uint32_t temp;
|
||||
|
||||
|
|
@ -571,17 +603,18 @@ int param_gethex_ex(const char *line, int paramnum, uint8_t * data, int *hexcnt)
|
|||
if (*hexcnt % 2) //error if not complete hex bytes
|
||||
return 1;
|
||||
|
||||
for(i = 0; i < *hexcnt; i += 2) {
|
||||
if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1])) ) return 1;
|
||||
for (i = 0; i < *hexcnt; i += 2) {
|
||||
if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1]))) return 1;
|
||||
|
||||
sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
|
||||
sscanf((char[]) {line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
|
||||
data[i / 2] = temp & 0xff;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int param_gethex_to_eol(const char *line, int paramnum, uint8_t * data, int maxdatalen, int *datalen) {
|
||||
int param_gethex_to_eol(const char *line, int paramnum, uint8_t *data, int maxdatalen, int *datalen)
|
||||
{
|
||||
int bg, en;
|
||||
uint32_t temp;
|
||||
char buf[5] = {0};
|
||||
|
|
@ -627,7 +660,7 @@ int param_gethex_to_eol(const char *line, int paramnum, uint8_t * data, int maxd
|
|||
return 0;
|
||||
}
|
||||
|
||||
int param_getstr(const char *line, int paramnum, char * str, size_t buffersize)
|
||||
int param_getstr(const char *line, int paramnum, char *str, size_t buffersize)
|
||||
{
|
||||
int bg, en;
|
||||
|
||||
|
|
@ -655,15 +688,14 @@ https://github.com/ApertureLabsLtd/RFIDler/blob/master/firmware/Pic32/RFIDler.X/
|
|||
// returns number of bits converted
|
||||
int hextobinarray(char *target, char *source)
|
||||
{
|
||||
int length, i, count= 0;
|
||||
char* start = source;
|
||||
int length, i, count = 0;
|
||||
char *start = source;
|
||||
char x;
|
||||
|
||||
length = strlen(source);
|
||||
// process 4 bits (1 hex digit) at a time
|
||||
while(length--)
|
||||
{
|
||||
x= *(source++);
|
||||
while (length--) {
|
||||
x = *(source++);
|
||||
// capitalize
|
||||
if (x >= 'a' && x <= 'f')
|
||||
x -= 32;
|
||||
|
|
@ -677,8 +709,8 @@ int hextobinarray(char *target, char *source)
|
|||
return 0;
|
||||
}
|
||||
// output
|
||||
for(i= 0 ; i < 4 ; ++i, ++count)
|
||||
*(target++)= (x >> (3 - i)) & 1;
|
||||
for (i = 0 ; i < 4 ; ++i, ++count)
|
||||
*(target++) = (x >> (3 - i)) & 1;
|
||||
}
|
||||
|
||||
return count;
|
||||
|
|
@ -689,7 +721,7 @@ int hextobinstring(char *target, char *source)
|
|||
{
|
||||
int length;
|
||||
|
||||
if(!(length= hextobinarray(target, source)))
|
||||
if (!(length = hextobinarray(target, source)))
|
||||
return 0;
|
||||
binarraytobinstring(target, target, length);
|
||||
return length;
|
||||
|
|
@ -702,14 +734,13 @@ int binarraytohex(char *target, char *source, int length)
|
|||
unsigned char i, x;
|
||||
int j = length;
|
||||
|
||||
if(j % 4)
|
||||
if (j % 4)
|
||||
return 0;
|
||||
|
||||
while(j)
|
||||
{
|
||||
for(i= x= 0 ; i < 4 ; ++i)
|
||||
x += ( source[i] << (3 - i));
|
||||
sprintf(target,"%X", x);
|
||||
while (j) {
|
||||
for (i = x = 0 ; i < 4 ; ++i)
|
||||
x += (source[i] << (3 - i));
|
||||
sprintf(target, "%X", x);
|
||||
++target;
|
||||
source += 4;
|
||||
j -= 4;
|
||||
|
|
@ -722,16 +753,16 @@ void binarraytobinstring(char *target, char *source, int length)
|
|||
{
|
||||
int i;
|
||||
|
||||
for(i= 0 ; i < length ; ++i)
|
||||
*(target++)= *(source++) + '0';
|
||||
*target= '\0';
|
||||
for (i = 0 ; i < length ; ++i)
|
||||
*(target++) = *(source++) + '0';
|
||||
*target = '\0';
|
||||
}
|
||||
|
||||
// return parity bit required to match type
|
||||
uint8_t GetParity( uint8_t *bits, uint8_t type, int length)
|
||||
uint8_t GetParity(uint8_t *bits, uint8_t type, int length)
|
||||
{
|
||||
int x;
|
||||
for( x = 0 ; length > 0 ; --length)
|
||||
for (x = 0 ; length > 0 ; --length)
|
||||
x += bits[length - 1];
|
||||
x %= 2;
|
||||
return x ^ type;
|
||||
|
|
@ -740,28 +771,31 @@ uint8_t GetParity( uint8_t *bits, uint8_t type, int length)
|
|||
// add HID parity to binary array: EVEN prefix for 1st half of ID, ODD suffix for 2nd half
|
||||
void wiegand_add_parity(uint8_t *target, uint8_t *source, uint8_t length)
|
||||
{
|
||||
*(target++)= GetParity(source, EVEN, length / 2);
|
||||
*(target++) = GetParity(source, EVEN, length / 2);
|
||||
memcpy(target, source, length);
|
||||
target += length;
|
||||
*(target)= GetParity(source + length / 2, ODD, length / 2);
|
||||
*(target) = GetParity(source + length / 2, ODD, length / 2);
|
||||
}
|
||||
|
||||
// xor two arrays together for len items. The dst array contains the new xored values.
|
||||
void xor(unsigned char * dst, unsigned char * src, size_t len) {
|
||||
for( ; len > 0; len--,dst++,src++)
|
||||
*dst ^= *src;
|
||||
void xor(unsigned char *dst, unsigned char *src, size_t len)
|
||||
{
|
||||
for (; len > 0; len--, dst++, src++)
|
||||
*dst ^= *src;
|
||||
}
|
||||
|
||||
int32_t le24toh (uint8_t data[3]) {
|
||||
int32_t le24toh(uint8_t data[3])
|
||||
{
|
||||
return (data[2] << 16) | (data[1] << 8) | data[0];
|
||||
}
|
||||
// Pack a bitarray into a uint32_t.
|
||||
uint32_t PackBits(uint8_t start, uint8_t len, uint8_t* bits) {
|
||||
uint32_t PackBits(uint8_t start, uint8_t len, uint8_t *bits)
|
||||
{
|
||||
|
||||
if (len > 32) return 0;
|
||||
|
||||
int i = start;
|
||||
int j = len-1;
|
||||
int j = len - 1;
|
||||
uint32_t tmp = 0;
|
||||
|
||||
for (; j >= 0; --j, ++i)
|
||||
|
|
@ -772,12 +806,13 @@ uint32_t PackBits(uint8_t start, uint8_t len, uint8_t* bits) {
|
|||
|
||||
// RotateLeft - Ultralight, Desfire, works on byte level
|
||||
// 00-01-02 >> 01-02-00
|
||||
void rol(uint8_t *data, const size_t len){
|
||||
void rol(uint8_t *data, const size_t len)
|
||||
{
|
||||
uint8_t first = data[0];
|
||||
for (size_t i = 0; i < len-1; i++) {
|
||||
data[i] = data[i+1];
|
||||
for (size_t i = 0; i < len - 1; i++) {
|
||||
data[i] = data[i + 1];
|
||||
}
|
||||
data[len-1] = first;
|
||||
data[len - 1] = first;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -788,10 +823,12 @@ uint8_t pw_rev_A(uint8_t b) {
|
|||
return b;
|
||||
}
|
||||
*/
|
||||
uint8_t reflect8(uint8_t b) {
|
||||
uint8_t reflect8(uint8_t b)
|
||||
{
|
||||
return ((b * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
|
||||
}
|
||||
uint16_t reflect16(uint16_t b) {
|
||||
uint16_t reflect16(uint16_t b)
|
||||
{
|
||||
uint16_t v = 0;
|
||||
v |= (b & 0x8000) >> 15;
|
||||
v |= (b & 0x4000) >> 13;
|
||||
|
|
@ -817,74 +854,83 @@ uint16_t reflect16(uint16_t b) {
|
|||
Returns the value v with the bottom b [0,32] bits reflected.
|
||||
Example: reflect(0x3e23L,3) == 0x3e26
|
||||
*/
|
||||
uint32_t reflect(uint32_t v, int b) {
|
||||
uint32_t reflect(uint32_t v, int b)
|
||||
{
|
||||
uint32_t t = v;
|
||||
for ( int i = 0; i < b; ++i) {
|
||||
for (int i = 0; i < b; ++i) {
|
||||
if (t & 1)
|
||||
v |= BITMASK((b-1)-i);
|
||||
v |= BITMASK((b - 1) - i);
|
||||
else
|
||||
v &= ~BITMASK((b-1)-i);
|
||||
t>>=1;
|
||||
v &= ~BITMASK((b - 1) - i);
|
||||
t >>= 1;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
uint64_t HornerScheme(uint64_t num, uint64_t divider, uint64_t factor) {
|
||||
uint64_t remainder=0, quotient=0, result=0;
|
||||
remainder = num % divider;
|
||||
quotient = num / divider;
|
||||
if(!(quotient == 0 && remainder == 0))
|
||||
result += HornerScheme(quotient, divider, factor) * factor + remainder;
|
||||
return result;
|
||||
uint64_t HornerScheme(uint64_t num, uint64_t divider, uint64_t factor)
|
||||
{
|
||||
uint64_t remainder = 0, quotient = 0, result = 0;
|
||||
remainder = num % divider;
|
||||
quotient = num / divider;
|
||||
if (!(quotient == 0 && remainder == 0))
|
||||
result += HornerScheme(quotient, divider, factor) * factor + remainder;
|
||||
return result;
|
||||
}
|
||||
|
||||
// determine number of logical CPU cores (use for multithreaded functions)
|
||||
extern int num_CPUs(void) {
|
||||
extern int num_CPUs(void)
|
||||
{
|
||||
#if defined(_WIN32)
|
||||
#include <sysinfoapi.h>
|
||||
#include <sysinfoapi.h>
|
||||
SYSTEM_INFO sysinfo;
|
||||
GetSystemInfo(&sysinfo);
|
||||
return sysinfo.dwNumberOfProcessors;
|
||||
#elif defined(__linux__) || defined(__APPLE__)
|
||||
#include <unistd.h>
|
||||
#include <unistd.h>
|
||||
return sysconf(_SC_NPROCESSORS_ONLN);
|
||||
#else
|
||||
return 1;
|
||||
#endif
|
||||
}
|
||||
|
||||
extern void str_lower(char *s ){
|
||||
for(int i=0; i < strlen(s); i++)
|
||||
s[i] = tolower( s[i] );
|
||||
extern void str_lower(char *s)
|
||||
{
|
||||
for (int i = 0; i < strlen(s); i++)
|
||||
s[i] = tolower(s[i]);
|
||||
}
|
||||
extern bool str_startswith(const char *s, const char *pre) {
|
||||
extern bool str_startswith(const char *s, const char *pre)
|
||||
{
|
||||
return strncmp(pre, s, strlen(pre)) == 0;
|
||||
}
|
||||
|
||||
// Replace unprintable characters with a dot in char buffer
|
||||
extern void clean_ascii(unsigned char *buf, size_t len) {
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
if (!isprint(buf[i]))
|
||||
buf[i] = '.';
|
||||
}
|
||||
extern void clean_ascii(unsigned char *buf, size_t len)
|
||||
{
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
if (!isprint(buf[i]))
|
||||
buf[i] = '.';
|
||||
}
|
||||
}
|
||||
|
||||
// replace \r \n to \0
|
||||
extern void strcleanrn(char *buf, size_t len) {
|
||||
extern void strcleanrn(char *buf, size_t len)
|
||||
{
|
||||
strcreplace(buf, len, '\n', '\0');
|
||||
strcreplace(buf, len, '\r', '\0');
|
||||
}
|
||||
|
||||
// replace char in buffer
|
||||
extern void strcreplace(char *buf, size_t len, char from, char to) {
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
if (buf[i] == from)
|
||||
buf[i] = to;
|
||||
}
|
||||
extern void strcreplace(char *buf, size_t len, char from, char to)
|
||||
{
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
if (buf[i] == from)
|
||||
buf[i] = to;
|
||||
}
|
||||
}
|
||||
|
||||
extern char *strmcopy(char *buf) {
|
||||
char* str = (char*) calloc(strlen(buf) + 1, sizeof(uint8_t));
|
||||
extern char *strmcopy(char *buf)
|
||||
{
|
||||
char *str = (char *) calloc(strlen(buf) + 1, sizeof(uint8_t));
|
||||
if (str != NULL) {
|
||||
memset(str, 0, strlen(buf) + 1);
|
||||
strcpy(str, buf);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue