[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 "util.h"

#include <stdint.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "data.h"

#ifdef _WIN32
#include <windows.h>
#endif

#define MAX_BIN_BREAK_LENGTH   (3072+384+1)

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

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

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

  Ntty.c_iflag          = 0x0000;   // input mode
  Ntty.c_oflag          = 0x0000;   // output mode
  Ntty.c_lflag         &= ~ICANON;  // control mode = raw
  Ntty.c_cc[VMIN]       = 1;        // return if at least 1 character is in the queue
  Ntty.c_cc[VTIME]      = 0;   	    // no timeout. Wait forever
  
  if (0 == (error = tcsetattr(STDIN_FILENO, TCSANOW, &Ntty))) {   // set new attributes
    error += ioctl(STDIN_FILENO, FIONREAD, &cnt);                 // get number of characters availabe
    error += tcsetattr(STDIN_FILENO, TCSANOW, &Otty);             // reset attributes
  }

  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; 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 > 255) ? 255 : len;
	// max 255 bytes * 3 + 2 characters = 767 in buffer
	sprintf(tmp, "%s| ", sprint_hex(data, max_len) );
	
	size_t i = 0;
	size_t pos = (max_len * 3)+2;
	// add another 255 characters ascii = 1020 characters of buffer used
	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;
	}
}

// Swap bit order on a uint32_t value.  Can be limited by nrbits just use say 8bits reversal
// And clears the rest of the bits.
uint32_t SwapBits(uint32_t value, int nrbits) {
	uint32_t newvalue = 0;
	for(int i = 0; i < nrbits; i++) {
		newvalue ^= ((value >> i) & 1) << (nrbits - 1 - i);
	}
	return newvalue;
}

// 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 and 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;
}


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

	return en - bg + 1;
}

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) {
	int bg, en;
	
	if (param_getptr(line, &bg, &en, paramnum)) return 0x00;

	if (bg + indx > en)
		return '\0';
	
	return line[bg + indx];
}

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_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};

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

	*datalen = 0;
	
	int indx = bg;
	while (line[indx]) {
		if (line[indx] == '\t' || line[indx] == ' ') 
			continue;
		
		if (isxdigit(line[indx])) {
			buf[strlen(buf) + 1] = 0x00;
			buf[strlen(buf)] = line[indx];
		} else {
			// if we have symbols other than spaces and hex
			return 1;
		}				

		if (*datalen >= maxdatalen) {
			// if we dont have space in buffer and have symbols to translate
			return 2;
		}

		if (strlen(buf) >= 2) {
			sscanf(buf, "%x", &temp);
			data[*datalen] = (uint8_t)(temp & 0xff);
			*buf = 0;
			(*datalen)++;
		}
		
		indx++;
	}

	if (strlen(buf) > 0) 
		//error when not completed hex bytes
		return 3;
		
	return 0;
}

int param_getstr(const char *line, int paramnum, char * str, size_t buffersize)
{
	int bg, en;

	if (param_getptr(line, &bg, &en, paramnum)) {	
		return 0;
	}

	// Prevent out of bounds errors
	if (en - bg + 1 >= buffersize) {
		printf("out of bounds error: want %d bytes have %zd bytes\n", en - bg + 1 + 1, buffersize);
		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* start = source;
    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 {
        	printf("Discovered unknown character %c %d at idx %d of %s\n", x, x, source - start, start);
            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] = '.';
  }
}

// replace \r \n to \0
void strcleanrn(char *buf, size_t len) {
	strcreplace(buf, len, '\n', '\0');
	strcreplace(buf, len, '\r', '\0');
}

// replace char in buffer
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;
  }
}

char *strmcopy(char *buf) {
	char * str = NULL;
	if ((str = (char*) malloc(strlen(buf) + 1)) != NULL) {
		memset(str, 0, strlen(buf) + 1);
		strcpy(str, buf);
	}	
	return str;
}


// determine number of logical CPU cores (use for multithreaded functions)
extern int num_CPUs(void)
{
#if defined(_WIN32)
	#include <sysinfoapi.h>
	SYSTEM_INFO sysinfo;
	GetSystemInfo(&sysinfo);
	return sysinfo.dwNumberOfProcessors;
#elif defined(__linux__) || defined(__APPLE__)
	#include <unistd.h>
	return sysconf(_SC_NPROCESSORS_ONLN);
#else
	return 1;
#endif
}
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
	11	#include "util.h"
acf0582d	12
	13	#include <stdint.h>
	14	#include <string.h>
	15	#include <ctype.h>
	16	#include <stdlib.h>
	17	#include <stdio.h>
	18	#include <time.h>
	19	#include "data.h"
	20
ec9c7112	21	#ifdef _WIN32
	22	#include <windows.h>
	23	#endif
	24
ace26dbd	25	#define MAX_BIN_BREAK_LENGTH (3072+384+1)
534983d7	26
cb64309e	27	#ifndef _WIN32
873014de M	28	#include <termios.h>
873014de M	29	#include <sys/ioctl.h>
8c0ccdef	30	#include <unistd.h>
79544b28	31
f397b5cc M	32	int ukbhit(void)
	33	{
	34	int cnt = 0;
	35	int error;
	36	static struct termios Otty, Ntty;
	37
8c0ccdef	38	if ( tcgetattr(STDIN_FILENO, &Otty) == -1 ) return -1;
f397b5cc M	39	Ntty = Otty;
f397b5cc M	40
8c0ccdef	41	Ntty.c_iflag = 0x0000; // input mode
	42	Ntty.c_oflag = 0x0000; // output mode
	43	Ntty.c_lflag &= ~ICANON; // control mode = raw
	44	Ntty.c_cc[VMIN] = 1; // return if at least 1 character is in the queue
	45	Ntty.c_cc[VTIME] = 0; // no timeout. Wait forever
	46
	47	if (0 == (error = tcsetattr(STDIN_FILENO, TCSANOW, &Ntty))) { // set new attributes
	48	error += ioctl(STDIN_FILENO, FIONREAD, &cnt); // get number of characters availabe
	49	error += tcsetattr(STDIN_FILENO, TCSANOW, &Otty); // reset attributes
f397b5cc M	50	}
	51
	52	return ( error == 0 ? cnt : -1 );
	53	}
	54
	55	#else
acf0582d	56
f397b5cc M	57	#include <conio.h>
	58	int ukbhit(void) {
	59	return kbhit();
	60	}
	61	#endif
	62
55acbb2a	63	// log files functions
b915fda3	64	void AddLogLine(char file, char extData, char *c) {
55acbb2a	65	FILE *fLog = NULL;
b915fda3	66	char filename[FILE_PATH_SIZE] = {0x00};
	67	int len = 0;
	68
	69	len = strlen(file);
	70	if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
	71	memcpy(filename, file, len);
	72
	73	fLog = fopen(filename, "a");
55acbb2a	74	if (!fLog) {
b915fda3	75	printf("Could not append log file %s", filename);
55acbb2a M	76	return;
	77	}
	78
	79	fprintf(fLog, "%s", extData);
	80	fprintf(fLog, "%s\n", c);
	81	fclose(fLog);
	82	}
	83
	84	void AddLogHex(char fileName, char extData, const uint8_t * data, const size_t len){
	85	AddLogLine(fileName, extData, sprint_hex(data, len));
	86	}
	87
	88	void AddLogUint64(char fileName, char extData, const uint64_t data) {
	89	char buf[100] = {0};
	90	sprintf(buf, "%x%x", (unsigned int)((data & 0xFFFFFFFF00000000) >> 32), (unsigned int)(data & 0xFFFFFFFF));
	91	AddLogLine(fileName, extData, buf);
	92	}
	93
	94	void AddLogCurrentDT(char *fileName) {
	95	char buff[20];
	96	struct tm *curTime;
	97
	98	time_t now = time(0);
	99	curTime = gmtime(&now);
	100
	101	strftime (buff, sizeof(buff), "%Y-%m-%d %H:%M:%S", curTime);
	102	AddLogLine(fileName, "\nanticollision: ", buff);
	103	}
	104
e0c635d1	105	void FillFileNameByUID(char fileName, uint8_t uid, char *ext, int byteCount) {
55acbb2a M	106	char * fnameptr = fileName;
	107	memset(fileName, 0x00, 200);
	108
e0c635d1	109	for (int j = 0; j < byteCount; j++, fnameptr += 2)
d1869c33	110	sprintf(fnameptr, "%02x", (unsigned int) uid[j]);
55acbb2a	111	sprintf(fnameptr, "%s", ext);
55acbb2a M	112	}
	113
	114	// printing and converting functions
f397b5cc	115
534983d7	116	void print_hex(const uint8_t * data, const size_t len)
	117	{
	118	size_t i;
	119
	120	for (i=0; i < len; i++)
	121	printf("%02x ", data[i]);
	122
	123	printf("\n");
	124	}
	125
59f726c9	126	void print_hex_break(const uint8_t *data, const size_t len, uint8_t breaks) {
	127
	128	int rownum = 0;
	129	printf("[%02d] \| ", rownum);
	130	for (int i = 0; i < len; ++i) {
	131
	132	printf("%02X ", data[i]);
	133
	134	// check if a line break is needed
	135	if ( breaks > 0 && !((i+1) % breaks) && (i+1 < len) ) {
	136	++rownum;
	137	printf("\n[%02d] \| ", rownum);
	138	}
	139	}
	140	printf("\n");
	141	}
	142
4973f23d	143	char sprint_hex(const uint8_t data, const size_t len) {
b915fda3	144
b915fda3	145	int maxLen = ( len > 1024/3) ? 1024/3 : len;
534983d7	146	static char buf[1024];
c585a5cf	147	memset(buf, 0x00, 1024);
4973f23d	148	char *tmp = buf;
534983d7	149	size_t i;
534983d7	150
b915fda3	151	for (i=0; i < maxLen; ++i, tmp += 3)
d1869c33	152	sprintf(tmp, "%02x ", (unsigned int) data[i]);
534983d7	153
	154	return buf;
	155	}
f89c7050	156
2767fc02	157	char sprint_bin_break(const uint8_t data, const size_t len, const uint8_t breaks) {
ace26dbd	158	// make sure we don't go beyond our char array memory
7bc6fac3	159	int max_len;
	160	if (breaks==0)
	161	max_len = ( len > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len;
	162	else
	163	max_len = ( len+(len/breaks) > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len+(len/breaks);
	164
ace26dbd	165	static char buf[MAX_BIN_BREAK_LENGTH]; // 3072 + end of line characters if broken at 8 bits
	166	//clear memory
	167	memset(buf, 0x00, sizeof(buf));
2767fc02	168	char *tmp = buf;
79544b28	169
ace26dbd	170	size_t in_index = 0;
ace26dbd	171	// loop through the out_index to make sure we don't go too far
b97311b1	172	for (size_t out_index=0; out_index < max_len; out_index++) {
8ea57060	173	// set character - (should be binary but verify it isn't more than 1 digit)
8ea57060	174	if (data[in_index]<10)
d1869c33	175	sprintf(tmp++, "%u", (unsigned int) data[in_index]);
6ca1477c	176	// check if a line break is needed and we have room to print it in our array
b9957414	177	if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 < max_len) ) {
ace26dbd	178	// increment and print line break
ace26dbd	179	out_index++;
2767fc02	180	sprintf(tmp++, "%s","\n");
ace26dbd	181	}
ace26dbd	182	in_index++;
2767fc02	183	}
79544b28	184
	185	return buf;
	186	}
	187
2767fc02	188	char sprint_bin(const uint8_t data, const size_t len) {
	189	return sprint_bin_break(data, len, 0);
	190	}
59f726c9	191
	192	char sprint_hex_ascii(const uint8_t data, const size_t len) {
	193	static char buf[1024];
	194	char *tmp = buf;
	195	memset(buf, 0x00, 1024);
bf824347	196	size_t max_len = (len > 255) ? 255 : len;
bf824347	197	// max 255 bytes * 3 + 2 characters = 767 in buffer
59f726c9	198	sprintf(tmp, "%s\| ", sprint_hex(data, max_len) );
	199
	200	size_t i = 0;
	201	size_t pos = (max_len * 3)+2;
bf824347	202	// add another 255 characters ascii = 1020 characters of buffer used
bf824347	203	while(i < max_len) {
59f726c9	204	char c = data[i];
	205	if ( (c < 32) \|\| (c == 127))
	206	c = '.';
	207	sprintf(tmp+pos+i, "%c", c);
	208	++i;
	209	}
	210	return buf;
	211	}
	212
	213	char sprint_ascii(const uint8_t data, const size_t len) {
	214	static char buf[1024];
	215	char *tmp = buf;
	216	memset(buf, 0x00, 1024);
	217	size_t max_len = (len > 1010) ? 1010 : len;
	218	size_t i = 0;
	219	while(i < max_len){
	220	char c = data[i];
	221	tmp[i] = ((c < 32) \|\| (c == 127)) ? '.' : c;
	222	++i;
	223	}
	224	return buf;
	225	}
	226
f89c7050 M	227	void num_to_bytes(uint64_t n, size_t len, uint8_t* dest)
	228	{
	229	while (len--) {
	230	dest[len] = (uint8_t) n;
	231	n >>= 8;
	232	}
	233	}
	234
	235	uint64_t bytes_to_num(uint8_t* src, size_t len)
	236	{
	237	uint64_t num = 0;
	238	while (len--)
	239	{
	240	num = (num << 8) \| (*src);
	241	src++;
	242	}
	243	return num;
	244	}
f397b5cc	245
709665b5	246	void num_to_bytebits(uint64_t n, size_t len, uint8_t *dest) {
	247	while (len--) {
	248	dest[len] = n & 1;
	249	n >>= 1;
	250	}
	251	}
	252
59f726c9	253	//least significant bit first
	254	void num_to_bytebitsLSBF(uint64_t n, size_t len, uint8_t *dest) {
	255	for(int i = 0 ; i < len ; ++i) {
	256	dest[i] = n & 1;
	257	n >>= 1;
	258	}
	259	}
	260
2d42ea1e	261	// Swap bit order on a uint32_t value. Can be limited by nrbits just use say 8bits reversal
	262	// And clears the rest of the bits.
	263	uint32_t SwapBits(uint32_t value, int nrbits) {
	264	uint32_t newvalue = 0;
	265	for(int i = 0; i < nrbits; i++) {
	266	newvalue ^= ((value >> i) & 1) << (nrbits - 1 - i);
	267	}
	268	return newvalue;
	269	}
59f726c9	270
f9848fd6	271	// aa,bb,cc,dd,ee,ff,gg,hh, ii,jj,kk,ll,mm,nn,oo,pp
	272	// to
	273	// hh,gg,ff,ee,dd,cc,bb,aa, pp,oo,nn,mm,ll,kk,jj,ii
	274	// up to 64 bytes or 512 bits
2b3af97d	275	uint8_t SwapEndian64(const uint8_t src, const size_t len, const uint8_t blockSize){
	276	static uint8_t buf[64];
	277	memset(buf, 0x00, 64);
	278	uint8_t *tmp = buf;
	279	for (uint8_t block=0; block < (uint8_t)(len/blockSize); block++){
	280	for (size_t i = 0; i < blockSize; i++){
	281	tmp[i+(blockSizeblock)] = src[(blockSize-1-i)+(blockSizeblock)];
f9848fd6	282	}
f9848fd6	283	}
2b3af97d	284	return tmp;
f9848fd6	285	}
f9848fd6	286
59f726c9	287	// takes a uint8_t src array, for len items and reverses the byte order in blocksizes (8,16,32,64),
	288	// returns: the dest array contains the reordered src array.
	289	void SwapEndian64ex(const uint8_t src, const size_t len, const uint8_t blockSize, uint8_t dest){
	290	for (uint8_t block=0; block < (uint8_t)(len/blockSize); block++){
	291	for (size_t i = 0; i < blockSize; i++){
	292	dest[i+(blockSizeblock)] = src[(blockSize-1-i)+(blockSizeblock)];
	293	}
	294	}
	295	}
	296
79544b28	297	//assumes little endian
	298	char * printBits(size_t const size, void const * const ptr)
	299	{
	300	unsigned char b = (unsigned char) ptr;
	301	unsigned char byte;
	302	static char buf[1024];
	303	char * tmp = buf;
	304	int i, j;
	305
	306	for (i=size-1;i>=0;i--)
	307	{
	308	for (j=7;j>=0;j--)
	309	{
	310	byte = b[i] & (1<<j);
	311	byte >>= j;
d1869c33	312	sprintf(tmp, "%u", (unsigned int)byte);
79544b28	313	tmp++;
	314	}
	315	}
	316	return buf;
	317	}
	318
9ca155ba M	319	// -------------------------------------------------------------------------
	320	// string parameters lib
	321	// -------------------------------------------------------------------------
	322
f397b5cc M	323	// -------------------------------------------------------------------------
f397b5cc M	324	// line - param line
3a05a1e7	325	// bg, en - symbol numbers in param line of beginning and ending parameter
f397b5cc M	326	// paramnum - param number (from 0)
	327	// -------------------------------------------------------------------------
	328	int param_getptr(const char line, int bg, int *en, int paramnum)
	329	{
	330	int i;
	331	int len = strlen(line);
	332
	333	*bg = 0;
	334	*en = 0;
	335
	336	// skip spaces
	337	while (line[bg] ==' ' \|\| line[bg]=='\t') (*bg)++;
	338	if (*bg >= len) {
	339	return 1;
	340	}
	341
	342	for (i = 0; i < paramnum; i++) {
	343	while (line[bg]!=' ' && line[bg]!='\t' && line[bg] != '\0') (bg)++;
	344	while (line[bg]==' ' \|\| line[bg]=='\t') (*bg)++;
	345
	346	if (line[*bg] == '\0') return 1;
	347	}
	348
	349	en = bg;
	350	while (line[en] != ' ' && line[en] != '\t' && line[en] != '\0') (en)++;
	351
	352	(*en)--;
	353
	354	return 0;
	355	}
	356
31abe49f	357
3a05a1e7 OM	358	int param_getlength(const char *line, int paramnum)
	359	{
	360	int bg, en;
	361
	362	if (param_getptr(line, &bg, &en, paramnum)) return 0;
	363
	364	return en - bg + 1;
	365	}
	366
8019540b	367	char param_getchar(const char *line, int paramnum) {
	368	return param_getchar_indx(line, 0, paramnum);
	369	}
	370
	371	char param_getchar_indx(const char *line, int indx, int paramnum) {
f397b5cc M	372	int bg, en;
	373
	374	if (param_getptr(line, &bg, &en, paramnum)) return 0x00;
	375
8019540b	376	if (bg + indx > en)
	377	return '\0';
	378
	379	return line[bg + indx];
f397b5cc M	380	}
	381
	382	uint8_t param_get8(const char *line, int paramnum)
	383	{
6ca1477c	384	return param_get8ex(line, paramnum, 0, 10);
f397b5cc M	385	}
f397b5cc M	386
f6d9fb17	387	/**
31abe49f	388	* @brief Reads a decimal integer (actually, 0-254, not 255)
f6d9fb17 MHS	389	* @param line
f6d9fb17 MHS	390	* @param paramnum
31abe49f	391	* @return -1 if error
f6d9fb17 MHS	392	*/
	393	uint8_t param_getdec(const char line, int paramnum, uint8_t destination)
	394	{
31abe49f	395	uint8_t val = param_get8ex(line, paramnum, 255, 10);
31abe49f	396	if( (int8_t) val == -1) return 1;
f6d9fb17 MHS	397	(*destination) = val;
	398	return 0;
	399	}
	400	/**
	401	* @brief Checks if param is decimal
	402	* @param line
	403	* @param paramnum
	404	* @return
	405	*/
	406	uint8_t param_isdec(const char *line, int paramnum)
	407	{
	408	int bg, en;
	409	//TODO, check more thorougly
	410	if (!param_getptr(line, &bg, &en, paramnum)) return 1;
	411	// return strtoul(&line[bg], NULL, 10) & 0xff;
	412
	413	return 0;
	414	}
	415
f397b5cc M	416	uint8_t param_get8ex(const char *line, int paramnum, int deflt, int base)
	417	{
	418	int bg, en;
	419
	420	if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1	421	return strtoul(&line[bg], NULL, base) & 0xff;
f397b5cc M	422	else
	423	return deflt;
	424	}
	425
	426	uint32_t param_get32ex(const char *line, int paramnum, int deflt, int base)
	427	{
	428	int bg, en;
	429
	430	if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1	431	return strtoul(&line[bg], NULL, base);
f397b5cc M	432	else
	433	return deflt;
	434	}
	435
	436	uint64_t param_get64ex(const char *line, int paramnum, int deflt, int base)
	437	{
	438	int bg, en;
	439
	440	if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1	441	return strtoull(&line[bg], NULL, base);
f397b5cc M	442	else
f397b5cc M	443	return deflt;
f397b5cc M	444	}
	445
	446	int param_gethex(const char line, int paramnum, uint8_t data, int hexcnt)
	447	{
	448	int bg, en, temp, i;
	449
	450	if (hexcnt % 2)
	451	return 1;
	452
	453	if (param_getptr(line, &bg, &en, paramnum)) return 1;
	454
	455	if (en - bg + 1 != hexcnt)
	456	return 1;
	457
	458	for(i = 0; i < hexcnt; i += 2) {
	459	if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1])) ) return 1;
	460
	461	sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
	462	data[i / 2] = temp & 0xff;
	463	}
	464
	465	return 0;
	466	}
1a5a73ab	467	int param_gethex_ex(const char line, int paramnum, uint8_t data, int *hexcnt)
	468	{
	469	int bg, en, temp, i;
	470
	471	//if (hexcnt % 2)
	472	// return 1;
	473
	474	if (param_getptr(line, &bg, &en, paramnum)) return 1;
	475
	476	*hexcnt = en - bg + 1;
	477	if (*hexcnt % 2) //error if not complete hex bytes
	478	return 1;
aea4d766	479
1a5a73ab	480	for(i = 0; i < *hexcnt; i += 2) {
	481	if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1])) ) return 1;
	482
	483	sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
	484	data[i / 2] = temp & 0xff;
	485	}
	486
	487	return 0;
	488	}
8019540b	489
	490	int param_gethex_to_eol(const char line, int paramnum, uint8_t data, int maxdatalen, int *datalen) {
	491	int bg, en;
	492	uint32_t temp;
	493	char buf[5] = {0};
	494
	495	if (param_getptr(line, &bg, &en, paramnum)) return 1;
	496
	497	*datalen = 0;
	498
	499	int indx = bg;
	500	while (line[indx]) {
	501	if (line[indx] == '\t' \|\| line[indx] == ' ')
	502	continue;
	503
	504	if (isxdigit(line[indx])) {
	505	buf[strlen(buf) + 1] = 0x00;
	506	buf[strlen(buf)] = line[indx];
	507	} else {
	508	// if we have symbols other than spaces and hex
	509	return 1;
	510	}
	511
	512	if (*datalen >= maxdatalen) {
	513	// if we dont have space in buffer and have symbols to translate
	514	return 2;
	515	}
	516
	517	if (strlen(buf) >= 2) {
	518	sscanf(buf, "%x", &temp);
	519	data[*datalen] = (uint8_t)(temp & 0xff);
	520	*buf = 0;
	521	(*datalen)++;
	522	}
	523
	524	indx++;
	525	}
	526
	527	if (strlen(buf) > 0)
	528	//error when not completed hex bytes
	529	return 3;
	530
	531	return 0;
	532	}
	533
874572d4	534	int param_getstr(const char line, int paramnum, char str, size_t buffersize)
aea4d766	535	{
	536	int bg, en;
	537
874572d4 WM	538	if (param_getptr(line, &bg, &en, paramnum)) {
	539	return 0;
	540	}
	541
	542	// Prevent out of bounds errors
	543	if (en - bg + 1 >= buffersize) {
c95affa8	544	printf("out of bounds error: want %d bytes have %zd bytes\n", en - bg + 1 + 1, buffersize);
874572d4 WM	545	return 0;
874572d4 WM	546	}
aea4d766	547
	548	memcpy(str, line + bg, en - bg + 1);
	549	str[en - bg + 1] = 0;
	550
	551	return en - bg + 1;
	552	}
79544b28	553
	554	/*
	555	The following methods comes from Rfidler sourcecode.
	556	https://github.com/ApertureLabsLtd/RFIDler/blob/master/firmware/Pic32/RFIDler.X/src/
	557	*/
	558
	559	// convert hex to sequence of 0/1 bit values
	560	// returns number of bits converted
	561	int hextobinarray(char target, char source)
	562	{
	563	int length, i, count= 0;
874572d4	564	char* start = source;
79544b28	565	char x;
	566
	567	length = strlen(source);
	568	// process 4 bits (1 hex digit) at a time
	569	while(length--)
	570	{
	571	x= *(source++);
	572	// capitalize
	573	if (x >= 'a' && x <= 'f')
	574	x -= 32;
	575	// convert to numeric value
	576	if (x >= '0' && x <= '9')
	577	x -= '0';
	578	else if (x >= 'A' && x <= 'F')
	579	x -= 'A' - 10;
874572d4 WM	580	else {
874572d4 WM	581	printf("Discovered unknown character %c %d at idx %d of %s\n", x, x, source - start, start);
79544b28	582	return 0;
874572d4	583	}
79544b28	584	// output
	585	for(i= 0 ; i < 4 ; ++i, ++count)
	586	*(target++)= (x >> (3 - i)) & 1;
	587	}
	588
	589	return count;
	590	}
	591
	592	// convert hex to human readable binary string
	593	int hextobinstring(char target, char source)
	594	{
	595	int length;
	596
	597	if(!(length= hextobinarray(target, source)))
	598	return 0;
	599	binarraytobinstring(target, target, length);
	600	return length;
	601	}
	602
	603	// convert binary array of 0x00/0x01 values to hex (safe to do in place as target will always be shorter than source)
	604	// return number of bits converted
1c4c0b06	605	int binarraytohex(char target,char source, int length)
79544b28	606	{
	607	unsigned char i, x;
	608	int j = length;
	609
	610	if(j % 4)
	611	return 0;
	612
	613	while(j)
	614	{
	615	for(i= x= 0 ; i < 4 ; ++i)
	616	x += ( source[i] << (3 - i));
d1869c33	617	sprintf(target,"%X", (unsigned int)x);
79544b28	618	++target;
	619	source += 4;
	620	j -= 4;
	621	}
	622	return length;
	623	}
	624
	625	// convert binary array to human readable binary
	626	void binarraytobinstring(char target, char source, int length)
	627	{
	628	int i;
	629
	630	for(i= 0 ; i < length ; ++i)
	631	(target++)= (source++) + '0';
	632	*target= '\0';
	633	}
	634
	635	// return parity bit required to match type
709665b5	636	uint8_t GetParity( uint8_t *bits, uint8_t type, int length)
79544b28	637	{
	638	int x;
	639
	640	for(x= 0 ; length > 0 ; --length)
	641	x += bits[length - 1];
	642	x %= 2;
	643
	644	return x ^ type;
	645	}
	646
	647	// add HID parity to binary array: EVEN prefix for 1st half of ID, ODD suffix for 2nd half
709665b5	648	void wiegand_add_parity(uint8_t target, uint8_t source, uint8_t length)
79544b28	649	{
	650	*(target++)= GetParity(source, EVEN, length / 2);
	651	memcpy(target, source, length);
	652	target += length;
	653	*(target)= GetParity(source + length / 2, ODD, length / 2);
	654	}
4973f23d	655
59f726c9	656	// xor two arrays together for len items. The dst array contains the new xored values.
4973f23d	657	void xor(unsigned char dst, unsigned char src, size_t len) {
	658	for( ; len > 0; len--,dst++,src++)
	659	dst ^= src;
	660	}
	661
	662	int32_t le24toh (uint8_t data[3]) {
	663	return (data[2] << 16) \| (data[1] << 8) \| data[0];
	664	}
c872d8c1	665	uint32_t le32toh (uint8_t *data) {
	666	return (uint32_t)( (data[3]<<24) \| (data[2]<<16) \| (data[1]<<8) \| data[0]);
	667	}
c4c3af7c	668
	669	// RotateLeft - Ultralight, Desfire, works on byte level
	670	// 00-01-02 >> 01-02-00
	671	void rol(uint8_t *data, const size_t len){
	672	uint8_t first = data[0];
	673	for (size_t i = 0; i < len-1; i++) {
	674	data[i] = data[i+1];
	675	}
	676	data[len-1] = first;
	677	}
d172c17c JC	678
	679
	680	// Replace unprintable characters with a dot in char buffer
	681	void clean_ascii(unsigned char *buf, size_t len) {
	682	for (size_t i = 0; i < len; i++) {
	683	if (!isprint(buf[i]))
	684	buf[i] = '.';
	685	}
	686	}
acf0582d	687
aa757f71 OM	688	// replace \r \n to \0
	689	void strcleanrn(char *buf, size_t len) {
	690	strcreplace(buf, len, '\n', '\0');
	691	strcreplace(buf, len, '\r', '\0');
	692	}
acf0582d	693
aa757f71 OM	694	// replace char in buffer
	695	void strcreplace(char *buf, size_t len, char from, char to) {
	696	for (size_t i = 0; i < len; i++) {
	697	if (buf[i] == from)
	698	buf[i] = to;
	699	}
	700	}
	701
	702	char strmcopy(char buf) {
	703	char * str = NULL;
	704	if ((str = (char*) malloc(strlen(buf) + 1)) != NULL) {
	705	memset(str, 0, strlen(buf) + 1);
	706	strcpy(str, buf);
	707	}
	708	return str;
	709	}
acf0582d	710
c48c4d78	711
	712	// determine number of logical CPU cores (use for multithreaded functions)
	713	extern int num_CPUs(void)
	714	{
	715	#if defined(_WIN32)
	716	#include <sysinfoapi.h>
	717	SYSTEM_INFO sysinfo;
	718	GetSystemInfo(&sysinfo);
	719	return sysinfo.dwNumberOfProcessors;
	720	#elif defined(__linux__) \|\| defined(__APPLE__)
	721	#include <unistd.h>
	722	return sysconf(_SC_NPROCESSORS_ONLN);
	723	#else
	724	return 1;
	725	#endif
	726	}
ec9c7112	727