[proxmark3-svn] / client / util.c

//-----------------------------------------------------------------------------
// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
//
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
// at your option, any later version. See the LICENSE.txt file for the text of
// the license.
//-----------------------------------------------------------------------------
// utilities
//-----------------------------------------------------------------------------

#include <ctype.h>
#include "util.h"
#define MAX_BIN_BREAK_LENGTH   (3072+384+1)

#ifndef _WIN32
#include <termios.h>
#include <sys/ioctl.h> 


int ukbhit(void)
{
  int cnt = 0;
  int error;
  static struct termios Otty, Ntty;


  if ( tcgetattr( 0, &Otty) == -1 ) return -1;
  Ntty = Otty;

  Ntty.c_iflag          = 0;       /* input mode                */
  Ntty.c_oflag          = 0;       /* output mode               */
  Ntty.c_lflag         &= ~ICANON; /* raw mode */
  Ntty.c_cc[VMIN]       = CMIN;    /* minimum time to wait      */
  Ntty.c_cc[VTIME]      = CTIME;   /* minimum characters to wait for */

  if (0 == (error = tcsetattr(0, TCSANOW, &Ntty))) {
    error += ioctl(0, FIONREAD, &cnt);
    error += tcsetattr(0, TCSANOW, &Otty);
  }

  return ( error == 0 ? cnt : -1 );
}

#else
#include <conio.h>
int ukbhit(void) {
	return kbhit();
}
#endif

// log files functions
void AddLogLine(char *file, char *extData, char *c) {
	FILE *fLog = NULL;
    char filename[FILE_PATH_SIZE] = {0x00};
    int len = 0;

    len = strlen(file);
    if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
    memcpy(filename, file, len);
   
	fLog = fopen(filename, "a");
	if (!fLog) {
		printf("Could not append log file %s", filename);
		return;
	}

	fprintf(fLog, "%s", extData);
	fprintf(fLog, "%s\n", c);
	fclose(fLog);
}

void AddLogHex(char *fileName, char *extData, const uint8_t * data, const size_t len){
	AddLogLine(fileName, extData, sprint_hex(data, len));
}

void AddLogUint64(char *fileName, char *extData, const uint64_t data) {
  char buf[100] = {0};
	sprintf(buf, "%x%x", (unsigned int)((data & 0xFFFFFFFF00000000) >> 32), (unsigned int)(data & 0xFFFFFFFF));
	AddLogLine(fileName, extData, buf);
}

void AddLogCurrentDT(char *fileName) {
	char buff[20];
	struct tm *curTime;

	time_t now = time(0);
	curTime = gmtime(&now);

	strftime (buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", curTime);
	AddLogLine(fileName, "\nanticollision: ", buff);
}

void FillFileNameByUID(char *fileName, uint8_t * uid, char *ext, int byteCount) {
	char * fnameptr = fileName;
	memset(fileName, 0x00, 200);
	
	for (int j = 0; j < byteCount; j++, fnameptr += 2)
		sprintf(fnameptr, "%02x", (unsigned int) uid[j]); 
	sprintf(fnameptr, "%s", ext); 
}

// printing and converting functions

void print_hex(const uint8_t * data, const size_t len)
{
	size_t 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) {

	int rownum = 0;
	printf("[%02d] | ", rownum);
	for (int i = 0; i < len; ++i) {

		printf("%02X ", data[i]);
		
		// check if a line break is needed
		if ( breaks > 0 && !((i+1) % breaks) && (i+1 < len) ) {
			++rownum;
			printf("\n[%02d] | ", rownum);
		}
	}
	printf("\n");
}

char *sprint_hex(const uint8_t *data, const size_t len) {
	
	int maxLen = ( len > 1024/3) ? 1024/3 : len;
	static char buf[1024];
	memset(buf, 0x00, 1024);
	char *tmp = buf;
	size_t i;

	for (i=0; i < maxLen; ++i, tmp += 3)
		sprintf(tmp, "%02x ", (unsigned int) data[i]);

	return buf;
}

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
	int max_len;
	if (breaks==0)
		max_len = ( len > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len;
	else
		max_len = ( len+(len/breaks) > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len+(len/breaks);

	static char buf[MAX_BIN_BREAK_LENGTH]; // 3072 + end of line characters if broken at 8 bits
	//clear memory
	memset(buf, 0x00, sizeof(buf));
	char *tmp = buf;

	size_t in_index = 0;
	// loop through the out_index to make sure we don't go too far
	for (size_t out_index=0; out_index < max_len-1; out_index++) {
		// set character - (should be binary but verify it isn't more than 1 digit)
		if (data[in_index]<10)
			sprintf(tmp++, "%u", (unsigned int) 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 != max_len) ) {
			// increment and print line break
			out_index++;
			sprintf(tmp++, "%s","\n");
		}
		in_index++;
	}

	return buf;
}

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) {
	static char buf[1024];
	char *tmp = buf;
	memset(buf, 0x00, 1024);
	size_t max_len = (len > 1010) ? 1010 : len;

	sprintf(tmp, "%s| ", sprint_hex(data, max_len) );
	
	size_t i = 0;
	size_t pos = (max_len * 3)+2;
	while(i < max_len){
		char c = data[i];
		if ( (c < 32) || (c == 127))
			c = '.';
		sprintf(tmp+pos+i, "%c",  c);
		++i;
	}
	return buf;
}

char *sprint_ascii(const uint8_t *data, const size_t len) {
	static char buf[1024];
	char *tmp = buf;
	memset(buf, 0x00, 1024);
	size_t max_len = (len > 1010) ? 1010 : len;
	size_t i = 0;
	while(i < max_len){
		char c = data[i];
		tmp[i] = ((c < 32) || (c == 127)) ? '.' : c;
		++i;
	}
	return buf;
}

void num_to_bytes(uint64_t n, size_t len, uint8_t* dest)
{
	while (len--) {
		dest[len] = (uint8_t) n;
		n >>= 8;
	}
}

uint64_t bytes_to_num(uint8_t* src, size_t len)
{
	uint64_t num = 0;
	while (len--)
	{
		num = (num << 8) | (*src);
		src++;
	}
	return num;
}

void num_to_bytebits(uint64_t	n, size_t len, uint8_t *dest) {
	while (len--) {
		dest[len] = n & 1;
		n >>= 1;
	}
}

//least significant bit first
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;
	}
}


// aa,bb,cc,dd,ee,ff,gg,hh, ii,jj,kk,ll,mm,nn,oo,pp
// 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){
	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)];
		}
	}
	return tmp;
}

// 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)];
		}
	}
}

//assumes little endian
char * printBits(size_t const size, void const * const ptr)
{
    unsigned char *b = (unsigned char*) ptr;	
    unsigned char byte;
	static char buf[1024];
	char * tmp = buf;
    int i, j;

    for (i=size-1;i>=0;i--)
    {
        for (j=7;j>=0;j--)
        {
            byte = b[i] & (1<<j);
            byte >>= j;
            sprintf(tmp, "%u", (unsigned int)byte);
			tmp++;
        }
    }
	return buf;
}

//  -------------------------------------------------------------------------
//  string parameters lib
//  -------------------------------------------------------------------------

//  -------------------------------------------------------------------------
//  line     - param line
//  bg, en   - symbol numbers in param line of beginning an ending parameter
//  paramnum - param number (from 0)
//  -------------------------------------------------------------------------
int param_getptr(const char *line, int *bg, int *en, int paramnum)
{
	int i;
	int len = strlen(line);
	
	*bg = 0;
	*en = 0;
	
  // 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)++;
		
		if (line[*bg] == '\0') return 1;
	}
	
	*en = *bg;
	while (line[*en] != ' ' && line[*en] != '\t' && line[*en] != '\0') (*en)++;
	
	(*en)--;

	return 0;
}


char param_getchar(const char *line, int paramnum)
{
	int bg, en;
	
	if (param_getptr(line, &bg, &en, paramnum)) return 0x00;

	return line[bg];
}

uint8_t param_get8(const char *line, int paramnum)
{
	return param_get8ex(line, paramnum, 0, 10);
}

/**
 * @brief Reads a decimal integer (actually, 0-254, not 255)
 * @param line
 * @param paramnum
 * @return -1 if error
 */
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;
	(*destination) = val;
	return 0;
}
/**
 * @brief Checks if param is decimal
 * @param line
 * @param paramnum
 * @return
 */
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 0;
}

uint8_t param_get8ex(const char *line, int paramnum, int deflt, int base)
{
	int bg, en;

	if (!param_getptr(line, &bg, &en, paramnum)) 
		return strtoul(&line[bg], NULL, base) & 0xff;
	else
		return deflt;
}

uint32_t param_get32ex(const char *line, int paramnum, int deflt, int base)
{
	int bg, en;

	if (!param_getptr(line, &bg, &en, paramnum)) 
		return strtoul(&line[bg], NULL, base);
	else
		return deflt;
}

uint64_t param_get64ex(const char *line, int paramnum, int deflt, int base)
{
	int bg, en;

	if (!param_getptr(line, &bg, &en, paramnum)) 
		return strtoull(&line[bg], NULL, base);
	else
		return deflt;
}

int param_gethex(const char *line, int paramnum, uint8_t * data, int hexcnt)
{
	int bg, en, temp, i;

	if (hexcnt % 2)
		return 1;
	
	if (param_getptr(line, &bg, &en, paramnum)) return 1;

	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;
		
		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 bg, en, temp, i;

	//if (hexcnt % 2)
	//	return 1;
	
	if (param_getptr(line, &bg, &en, paramnum)) return 1;

	*hexcnt = en - bg + 1;
	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;
		
		sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
		data[i / 2] = temp & 0xff;
	}	

	return 0;
}
int param_getstr(const char *line, int paramnum, char * str)
{
	int bg, en;

	if (param_getptr(line, &bg, &en, paramnum)) return 0;
	
	memcpy(str, line + bg, en - bg + 1);
	str[en - bg + 1] = 0;
	
	return en - bg + 1;
}

/*
The following methods comes from Rfidler sourcecode.
https://github.com/ApertureLabsLtd/RFIDler/blob/master/firmware/Pic32/RFIDler.X/src/
*/

// convert hex to sequence of 0/1 bit values
// returns number of bits converted
int hextobinarray(char *target, char *source)
{
    int length, i, count= 0;
    char x;

    length = strlen(source);
    // process 4 bits (1 hex digit) at a time
    while(length--)
    {
        x= *(source++);
        // capitalize
        if (x >= 'a' && x <= 'f')
            x -= 32;
        // convert to numeric value
        if (x >= '0' && x <= '9')
            x -= '0';
        else if (x >= 'A' && x <= 'F')
            x -= 'A' - 10;
        else
            return 0;
        // output
        for(i= 0 ; i < 4 ; ++i, ++count)
            *(target++)= (x >> (3 - i)) & 1;
    }
    
    return count;
}

// convert hex to human readable binary string
int hextobinstring(char *target, char *source)
{
    int length;

    if(!(length= hextobinarray(target, source)))
        return 0;
    binarraytobinstring(target, target, length);
    return length;
}

// convert binary array of 0x00/0x01 values to hex (safe to do in place as target will always be shorter than source)
// return number of bits converted
int binarraytohex(char *target,char *source, int length)
{
    unsigned char i, x;
    int j = length;

    if(j % 4)
        return 0;

    while(j)
    {
        for(i= x= 0 ; i < 4 ; ++i)
            x +=  ( source[i] << (3 - i));
        sprintf(target,"%X", (unsigned int)x);
        ++target;
        source += 4;
        j -= 4;
    }
    return length;
}

// convert binary array to human readable binary
void binarraytobinstring(char *target, char *source,  int length)
{
    int i;

    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)
{
    int x;

    for(x= 0 ; length > 0 ; --length)
        x += bits[length - 1];
    x %= 2;

    return x ^ type;
}

// 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);
    memcpy(target, source, length);
    target += length;
    *(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;
}

int32_t le24toh (uint8_t data[3]) {
    return (data[2] << 16) | (data[1] << 8) | data[0];
}
uint32_t le32toh (uint8_t *data) {
	return (uint32_t)( (data[3]<<24) | (data[2]<<16) | (data[1]<<8) | data[0]);
}

// RotateLeft - Ultralight, Desfire, works on byte level
// 00-01-02  >> 01-02-00
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];
    }
    data[len-1] = first;
}


// Replace unprintable characters with a dot in char buffer
void clean_ascii(unsigned char *buf, size_t len) {
  for (size_t i = 0; i < len; i++) {
    if (!isprint(buf[i]))
      buf[i] = '.';
  }
}
Commit	Line	Data
20f9a2a1 M	1	//-----------------------------------------------------------------------------
	2	// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
	3	//
	4	// This code is licensed to you under the terms of the GNU GPL, version 2 or,
	5	// at your option, any later version. See the LICENSE.txt file for the text of
	6	// the license.
	7	//-----------------------------------------------------------------------------
	8	// utilities
	9	//-----------------------------------------------------------------------------
	10
d172c17c	11	#include <ctype.h>
20f9a2a1	12	#include "util.h"
ace26dbd	13	#define MAX_BIN_BREAK_LENGTH (3072+384+1)
534983d7	14
cb64309e	15	#ifndef _WIN32
873014de M	16	#include <termios.h>
873014de M	17	#include <sys/ioctl.h>
79544b28	18
ace26dbd	19
f397b5cc M	20	int ukbhit(void)
	21	{
	22	int cnt = 0;
	23	int error;
	24	static struct termios Otty, Ntty;
	25
	26
8ea57060	27	if ( tcgetattr( 0, &Otty) == -1 ) return -1;
f397b5cc M	28	Ntty = Otty;
	29
	30	Ntty.c_iflag = 0; /* input mode */
	31	Ntty.c_oflag = 0; /* output mode */
	32	Ntty.c_lflag &= ~ICANON; /* raw mode */
	33	Ntty.c_cc[VMIN] = CMIN; /* minimum time to wait */
	34	Ntty.c_cc[VTIME] = CTIME; /* minimum characters to wait for */
	35
	36	if (0 == (error = tcsetattr(0, TCSANOW, &Ntty))) {
	37	error += ioctl(0, FIONREAD, &cnt);
	38	error += tcsetattr(0, TCSANOW, &Otty);
	39	}
	40
	41	return ( error == 0 ? cnt : -1 );
	42	}
	43
	44	#else
	45	#include <conio.h>
	46	int ukbhit(void) {
	47	return kbhit();
	48	}
	49	#endif
	50
55acbb2a	51	// log files functions
b915fda3	52	void AddLogLine(char file, char extData, char *c) {
55acbb2a	53	FILE *fLog = NULL;
b915fda3	54	char filename[FILE_PATH_SIZE] = {0x00};
	55	int len = 0;
	56
	57	len = strlen(file);
	58	if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
	59	memcpy(filename, file, len);
	60
	61	fLog = fopen(filename, "a");
55acbb2a	62	if (!fLog) {
b915fda3	63	printf("Could not append log file %s", filename);
55acbb2a M	64	return;
	65	}
	66
	67	fprintf(fLog, "%s", extData);
	68	fprintf(fLog, "%s\n", c);
	69	fclose(fLog);
	70	}
	71
	72	void AddLogHex(char fileName, char extData, const uint8_t * data, const size_t len){
	73	AddLogLine(fileName, extData, sprint_hex(data, len));
	74	}
	75
	76	void AddLogUint64(char fileName, char extData, const uint64_t data) {
	77	char buf[100] = {0};
	78	sprintf(buf, "%x%x", (unsigned int)((data & 0xFFFFFFFF00000000) >> 32), (unsigned int)(data & 0xFFFFFFFF));
	79	AddLogLine(fileName, extData, buf);
	80	}
	81
	82	void AddLogCurrentDT(char *fileName) {
	83	char buff[20];
	84	struct tm *curTime;
	85
	86	time_t now = time(0);
	87	curTime = gmtime(&now);
	88
	89	strftime (buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", curTime);
	90	AddLogLine(fileName, "\nanticollision: ", buff);
	91	}
	92
e0c635d1	93	void FillFileNameByUID(char fileName, uint8_t uid, char *ext, int byteCount) {
55acbb2a M	94	char * fnameptr = fileName;
	95	memset(fileName, 0x00, 200);
	96
e0c635d1	97	for (int j = 0; j < byteCount; j++, fnameptr += 2)
d1869c33	98	sprintf(fnameptr, "%02x", (unsigned int) uid[j]);
55acbb2a	99	sprintf(fnameptr, "%s", ext);
55acbb2a M	100	}
	101
	102	// printing and converting functions
f397b5cc	103
534983d7	104	void print_hex(const uint8_t * data, const size_t len)
	105	{
	106	size_t i;
	107
	108	for (i=0; i < len; i++)
	109	printf("%02x ", data[i]);
	110
	111	printf("\n");
	112	}
	113
59f726c9	114	void print_hex_break(const uint8_t *data, const size_t len, uint8_t breaks) {
	115
	116	int rownum = 0;
	117	printf("[%02d] \| ", rownum);
	118	for (int i = 0; i < len; ++i) {
	119
	120	printf("%02X ", data[i]);
	121
	122	// check if a line break is needed
	123	if ( breaks > 0 && !((i+1) % breaks) && (i+1 < len) ) {
	124	++rownum;
	125	printf("\n[%02d] \| ", rownum);
	126	}
	127	}
	128	printf("\n");
	129	}
	130
4973f23d	131	char sprint_hex(const uint8_t data, const size_t len) {
b915fda3	132
b915fda3	133	int maxLen = ( len > 1024/3) ? 1024/3 : len;
534983d7	134	static char buf[1024];
c585a5cf	135	memset(buf, 0x00, 1024);
4973f23d	136	char *tmp = buf;
534983d7	137	size_t i;
534983d7	138
b915fda3	139	for (i=0; i < maxLen; ++i, tmp += 3)
d1869c33	140	sprintf(tmp, "%02x ", (unsigned int) data[i]);
534983d7	141
	142	return buf;
	143	}
f89c7050	144
2767fc02	145	char sprint_bin_break(const uint8_t data, const size_t len, const uint8_t breaks) {
ace26dbd	146	// make sure we don't go beyond our char array memory
7bc6fac3	147	int max_len;
	148	if (breaks==0)
	149	max_len = ( len > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len;
	150	else
	151	max_len = ( len+(len/breaks) > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len+(len/breaks);
	152
ace26dbd	153	static char buf[MAX_BIN_BREAK_LENGTH]; // 3072 + end of line characters if broken at 8 bits
	154	//clear memory
	155	memset(buf, 0x00, sizeof(buf));
2767fc02	156	char *tmp = buf;
79544b28	157
ace26dbd	158	size_t in_index = 0;
ace26dbd	159	// loop through the out_index to make sure we don't go too far
59f726c9	160	for (size_t out_index=0; out_index < max_len-1; out_index++) {
8ea57060	161	// set character - (should be binary but verify it isn't more than 1 digit)
8ea57060	162	if (data[in_index]<10)
d1869c33	163	sprintf(tmp++, "%u", (unsigned int) data[in_index]);
6ca1477c	164	// check if a line break is needed and we have room to print it in our array
ace26dbd	165	if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 != max_len) ) {
	166	// increment and print line break
	167	out_index++;
2767fc02	168	sprintf(tmp++, "%s","\n");
ace26dbd	169	}
ace26dbd	170	in_index++;
2767fc02	171	}
79544b28	172
	173	return buf;
	174	}
	175
2767fc02	176	char sprint_bin(const uint8_t data, const size_t len) {
	177	return sprint_bin_break(data, len, 0);
	178	}
59f726c9	179
	180	char sprint_hex_ascii(const uint8_t data, const size_t len) {
	181	static char buf[1024];
	182	char *tmp = buf;
	183	memset(buf, 0x00, 1024);
	184	size_t max_len = (len > 1010) ? 1010 : len;
	185
	186	sprintf(tmp, "%s\| ", sprint_hex(data, max_len) );
	187
	188	size_t i = 0;
	189	size_t pos = (max_len * 3)+2;
	190	while(i < max_len){
	191	char c = data[i];
	192	if ( (c < 32) \|\| (c == 127))
	193	c = '.';
	194	sprintf(tmp+pos+i, "%c", c);
	195	++i;
	196	}
	197	return buf;
	198	}
	199
	200	char sprint_ascii(const uint8_t data, const size_t len) {
	201	static char buf[1024];
	202	char *tmp = buf;
	203	memset(buf, 0x00, 1024);
	204	size_t max_len = (len > 1010) ? 1010 : len;
	205	size_t i = 0;
	206	while(i < max_len){
	207	char c = data[i];
	208	tmp[i] = ((c < 32) \|\| (c == 127)) ? '.' : c;
	209	++i;
	210	}
	211	return buf;
	212	}
	213
f89c7050 M	214	void num_to_bytes(uint64_t n, size_t len, uint8_t* dest)
	215	{
	216	while (len--) {
	217	dest[len] = (uint8_t) n;
	218	n >>= 8;
	219	}
	220	}
	221
	222	uint64_t bytes_to_num(uint8_t* src, size_t len)
	223	{
	224	uint64_t num = 0;
	225	while (len--)
	226	{
	227	num = (num << 8) \| (*src);
	228	src++;
	229	}
	230	return num;
	231	}
f397b5cc	232
709665b5	233	void num_to_bytebits(uint64_t n, size_t len, uint8_t *dest) {
	234	while (len--) {
	235	dest[len] = n & 1;
	236	n >>= 1;
	237	}
	238	}
	239
59f726c9	240	//least significant bit first
	241	void num_to_bytebitsLSBF(uint64_t n, size_t len, uint8_t *dest) {
	242	for(int i = 0 ; i < len ; ++i) {
	243	dest[i] = n & 1;
	244	n >>= 1;
	245	}
	246	}
	247
	248
f9848fd6	249	// aa,bb,cc,dd,ee,ff,gg,hh, ii,jj,kk,ll,mm,nn,oo,pp
	250	// to
	251	// hh,gg,ff,ee,dd,cc,bb,aa, pp,oo,nn,mm,ll,kk,jj,ii
	252	// up to 64 bytes or 512 bits
2b3af97d	253	uint8_t SwapEndian64(const uint8_t src, const size_t len, const uint8_t blockSize){
	254	static uint8_t buf[64];
	255	memset(buf, 0x00, 64);
	256	uint8_t *tmp = buf;
	257	for (uint8_t block=0; block < (uint8_t)(len/blockSize); block++){
	258	for (size_t i = 0; i < blockSize; i++){
	259	tmp[i+(blockSizeblock)] = src[(blockSize-1-i)+(blockSizeblock)];
f9848fd6	260	}
f9848fd6	261	}
2b3af97d	262	return tmp;
f9848fd6	263	}
f9848fd6	264
59f726c9	265	// takes a uint8_t src array, for len items and reverses the byte order in blocksizes (8,16,32,64),
	266	// returns: the dest array contains the reordered src array.
	267	void SwapEndian64ex(const uint8_t src, const size_t len, const uint8_t blockSize, uint8_t dest){
	268	for (uint8_t block=0; block < (uint8_t)(len/blockSize); block++){
	269	for (size_t i = 0; i < blockSize; i++){
	270	dest[i+(blockSizeblock)] = src[(blockSize-1-i)+(blockSizeblock)];
	271	}
	272	}
	273	}
	274
79544b28	275	//assumes little endian
	276	char * printBits(size_t const size, void const * const ptr)
	277	{
	278	unsigned char b = (unsigned char) ptr;
	279	unsigned char byte;
	280	static char buf[1024];
	281	char * tmp = buf;
	282	int i, j;
	283
	284	for (i=size-1;i>=0;i--)
	285	{
	286	for (j=7;j>=0;j--)
	287	{
	288	byte = b[i] & (1<<j);
	289	byte >>= j;
d1869c33	290	sprintf(tmp, "%u", (unsigned int)byte);
79544b28	291	tmp++;
	292	}
	293	}
	294	return buf;
	295	}
	296
9ca155ba M	297	// -------------------------------------------------------------------------
	298	// string parameters lib
	299	// -------------------------------------------------------------------------
	300
f397b5cc M	301	// -------------------------------------------------------------------------
	302	// line - param line
	303	// bg, en - symbol numbers in param line of beginning an ending parameter
	304	// paramnum - param number (from 0)
	305	// -------------------------------------------------------------------------
	306	int param_getptr(const char line, int bg, int *en, int paramnum)
	307	{
	308	int i;
	309	int len = strlen(line);
	310
	311	*bg = 0;
	312	*en = 0;
	313
	314	// skip spaces
	315	while (line[bg] ==' ' \|\| line[bg]=='\t') (*bg)++;
	316	if (*bg >= len) {
	317	return 1;
	318	}
	319
	320	for (i = 0; i < paramnum; i++) {
	321	while (line[bg]!=' ' && line[bg]!='\t' && line[bg] != '\0') (bg)++;
	322	while (line[bg]==' ' \|\| line[bg]=='\t') (*bg)++;
	323
	324	if (line[*bg] == '\0') return 1;
	325	}
	326
	327	en = bg;
	328	while (line[en] != ' ' && line[en] != '\t' && line[en] != '\0') (en)++;
	329
	330	(*en)--;
	331
	332	return 0;
	333	}
	334
31abe49f	335
f397b5cc M	336	char param_getchar(const char *line, int paramnum)
	337	{
	338	int bg, en;
	339
	340	if (param_getptr(line, &bg, &en, paramnum)) return 0x00;
	341
	342	return line[bg];
	343	}
	344
	345	uint8_t param_get8(const char *line, int paramnum)
	346	{
6ca1477c	347	return param_get8ex(line, paramnum, 0, 10);
f397b5cc M	348	}
f397b5cc M	349
f6d9fb17	350	/**
31abe49f	351	* @brief Reads a decimal integer (actually, 0-254, not 255)
f6d9fb17 MHS	352	* @param line
f6d9fb17 MHS	353	* @param paramnum
31abe49f	354	* @return -1 if error
f6d9fb17 MHS	355	*/
	356	uint8_t param_getdec(const char line, int paramnum, uint8_t destination)
	357	{
31abe49f	358	uint8_t val = param_get8ex(line, paramnum, 255, 10);
31abe49f	359	if( (int8_t) val == -1) return 1;
f6d9fb17 MHS	360	(*destination) = val;
	361	return 0;
	362	}
	363	/**
	364	* @brief Checks if param is decimal
	365	* @param line
	366	* @param paramnum
	367	* @return
	368	*/
	369	uint8_t param_isdec(const char *line, int paramnum)
	370	{
	371	int bg, en;
	372	//TODO, check more thorougly
	373	if (!param_getptr(line, &bg, &en, paramnum)) return 1;
	374	// return strtoul(&line[bg], NULL, 10) & 0xff;
	375
	376	return 0;
	377	}
	378
f397b5cc M	379	uint8_t param_get8ex(const char *line, int paramnum, int deflt, int base)
	380	{
	381	int bg, en;
	382
	383	if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1	384	return strtoul(&line[bg], NULL, base) & 0xff;
f397b5cc M	385	else
	386	return deflt;
	387	}
	388
	389	uint32_t param_get32ex(const char *line, int paramnum, int deflt, int base)
	390	{
	391	int bg, en;
	392
	393	if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1	394	return strtoul(&line[bg], NULL, base);
f397b5cc M	395	else
	396	return deflt;
	397	}
	398
	399	uint64_t param_get64ex(const char *line, int paramnum, int deflt, int base)
	400	{
	401	int bg, en;
	402
	403	if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1	404	return strtoull(&line[bg], NULL, base);
f397b5cc M	405	else
f397b5cc M	406	return deflt;
f397b5cc M	407	}
	408
	409	int param_gethex(const char line, int paramnum, uint8_t data, int hexcnt)
	410	{
	411	int bg, en, temp, i;
	412
	413	if (hexcnt % 2)
	414	return 1;
	415
	416	if (param_getptr(line, &bg, &en, paramnum)) return 1;
	417
	418	if (en - bg + 1 != hexcnt)
	419	return 1;
	420
	421	for(i = 0; i < hexcnt; i += 2) {
	422	if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1])) ) return 1;
	423
	424	sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
	425	data[i / 2] = temp & 0xff;
	426	}
	427
	428	return 0;
	429	}
1a5a73ab	430	int param_gethex_ex(const char line, int paramnum, uint8_t data, int *hexcnt)
	431	{
	432	int bg, en, temp, i;
	433
	434	//if (hexcnt % 2)
	435	// return 1;
	436
	437	if (param_getptr(line, &bg, &en, paramnum)) return 1;
	438
	439	*hexcnt = en - bg + 1;
	440	if (*hexcnt % 2) //error if not complete hex bytes
	441	return 1;
aea4d766	442
1a5a73ab	443	for(i = 0; i < *hexcnt; i += 2) {
	444	if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1])) ) return 1;
	445
	446	sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
	447	data[i / 2] = temp & 0xff;
	448	}
	449
	450	return 0;
	451	}
aea4d766	452	int param_getstr(const char line, int paramnum, char str)
	453	{
	454	int bg, en;
	455
	456	if (param_getptr(line, &bg, &en, paramnum)) return 0;
	457
	458	memcpy(str, line + bg, en - bg + 1);
	459	str[en - bg + 1] = 0;
	460
	461	return en - bg + 1;
	462	}
79544b28	463
	464	/*
	465	The following methods comes from Rfidler sourcecode.
	466	https://github.com/ApertureLabsLtd/RFIDler/blob/master/firmware/Pic32/RFIDler.X/src/
	467	*/
	468
	469	// convert hex to sequence of 0/1 bit values
	470	// returns number of bits converted
	471	int hextobinarray(char target, char source)
	472	{
	473	int length, i, count= 0;
	474	char x;
	475
	476	length = strlen(source);
	477	// process 4 bits (1 hex digit) at a time
	478	while(length--)
	479	{
	480	x= *(source++);
	481	// capitalize
	482	if (x >= 'a' && x <= 'f')
	483	x -= 32;
	484	// convert to numeric value
	485	if (x >= '0' && x <= '9')
	486	x -= '0';
	487	else if (x >= 'A' && x <= 'F')
	488	x -= 'A' - 10;
	489	else
	490	return 0;
	491	// output
	492	for(i= 0 ; i < 4 ; ++i, ++count)
	493	*(target++)= (x >> (3 - i)) & 1;
	494	}
	495
	496	return count;
	497	}
	498
	499	// convert hex to human readable binary string
	500	int hextobinstring(char target, char source)
	501	{
	502	int length;
	503
	504	if(!(length= hextobinarray(target, source)))
	505	return 0;
	506	binarraytobinstring(target, target, length);
	507	return length;
	508	}
	509
	510	// convert binary array of 0x00/0x01 values to hex (safe to do in place as target will always be shorter than source)
	511	// return number of bits converted
1c4c0b06	512	int binarraytohex(char target,char source, int length)
79544b28	513	{
	514	unsigned char i, x;
	515	int j = length;
	516
	517	if(j % 4)
	518	return 0;
	519
	520	while(j)
	521	{
	522	for(i= x= 0 ; i < 4 ; ++i)
	523	x += ( source[i] << (3 - i));
d1869c33	524	sprintf(target,"%X", (unsigned int)x);
79544b28	525	++target;
	526	source += 4;
	527	j -= 4;
	528	}
	529	return length;
	530	}
	531
	532	// convert binary array to human readable binary
	533	void binarraytobinstring(char target, char source, int length)
	534	{
	535	int i;
	536
	537	for(i= 0 ; i < length ; ++i)
	538	(target++)= (source++) + '0';
	539	*target= '\0';
	540	}
	541
	542	// return parity bit required to match type
709665b5	543	uint8_t GetParity( uint8_t *bits, uint8_t type, int length)
79544b28	544	{
	545	int x;
	546
	547	for(x= 0 ; length > 0 ; --length)
	548	x += bits[length - 1];
	549	x %= 2;
	550
	551	return x ^ type;
	552	}
	553
	554	// add HID parity to binary array: EVEN prefix for 1st half of ID, ODD suffix for 2nd half
709665b5	555	void wiegand_add_parity(uint8_t target, uint8_t source, uint8_t length)
79544b28	556	{
	557	*(target++)= GetParity(source, EVEN, length / 2);
	558	memcpy(target, source, length);
	559	target += length;
	560	*(target)= GetParity(source + length / 2, ODD, length / 2);
	561	}
4973f23d	562
59f726c9	563	// xor two arrays together for len items. The dst array contains the new xored values.
4973f23d	564	void xor(unsigned char dst, unsigned char src, size_t len) {
	565	for( ; len > 0; len--,dst++,src++)
	566	dst ^= src;
	567	}
	568
	569	int32_t le24toh (uint8_t data[3]) {
	570	return (data[2] << 16) \| (data[1] << 8) \| data[0];
	571	}
c872d8c1	572	uint32_t le32toh (uint8_t *data) {
	573	return (uint32_t)( (data[3]<<24) \| (data[2]<<16) \| (data[1]<<8) \| data[0]);
	574	}
c4c3af7c	575
	576	// RotateLeft - Ultralight, Desfire, works on byte level
	577	// 00-01-02 >> 01-02-00
	578	void rol(uint8_t *data, const size_t len){
	579	uint8_t first = data[0];
	580	for (size_t i = 0; i < len-1; i++) {
	581	data[i] = data[i+1];
	582	}
	583	data[len-1] = first;
	584	}
d172c17c JC	585
	586
	587	// Replace unprintable characters with a dot in char buffer
	588	void clean_ascii(unsigned char *buf, size_t len) {
	589	for (size_t i = 0; i < len; i++) {
	590	if (!isprint(buf[i]))
	591	buf[i] = '.';
	592	}
	593	}