proxmark3/armsrc/BigBuf.c

208 lines
6.2 KiB
C
Raw Normal View History

//-----------------------------------------------------------------------------
// Jonathan Westhues, Aug 2005
// Gerhard de Koning Gans, April 2008, May 2011
//
// 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.
//-----------------------------------------------------------------------------
// BigBuf and functions to allocate/free parts of it.
//-----------------------------------------------------------------------------
2016-07-07 16:01:50 +08:00
#include "BigBuf.h"
// BigBuf is the large multi-purpose buffer, typically used to hold A/D samples or traces.
// Also used to hold various smaller buffers and the Mifare Emulator Memory.
// declare it as uint32_t to achieve alignment to 4 Byte boundary
2019-03-10 07:00:59 +08:00
static uint32_t BigBuf[BIGBUF_SIZE / sizeof(uint32_t)];
/* BigBuf memory layout:
Pointer to highest available memory: BigBuf_hi
high BIGBUF_SIZE
reserved = BigBuf_malloc() subtracts amount from BigBuf_hi,
2019-03-10 03:34:41 +08:00
low 0x00
*/
// High memory mark
static uint16_t BigBuf_hi = BIGBUF_SIZE;
// pointer to the emulator memory.
static uint8_t *emulator_memory = NULL;
// trace related variables
2019-01-09 19:00:06 +08:00
static uint32_t traceLen = 0;
static bool tracing = true; //todo static?
// get the address of BigBuf
uint8_t *BigBuf_get_addr(void) {
2019-03-10 03:34:41 +08:00
return (uint8_t *)BigBuf;
}
// get the address of the emulator memory. Allocate part of Bigbuf for it, if not yet done
uint8_t *BigBuf_get_EM_addr(void) {
2019-03-10 03:34:41 +08:00
// not yet allocated
if (emulator_memory == NULL)
emulator_memory = BigBuf_malloc(CARD_MEMORY_SIZE);
2019-03-10 03:34:41 +08:00
return emulator_memory;
}
// clear ALL of BigBuf
void BigBuf_Clear(void) {
2019-03-10 03:34:41 +08:00
BigBuf_Clear_ext(true);
}
// clear ALL of BigBuf
void BigBuf_Clear_ext(bool verbose) {
2019-03-10 03:34:41 +08:00
memset(BigBuf, 0, BIGBUF_SIZE);
if (verbose)
Dbprintf("Buffer cleared (%i bytes)", BIGBUF_SIZE);
}
void BigBuf_Clear_EM(void) {
2019-03-10 03:34:41 +08:00
memset(BigBuf_get_EM_addr(), 0, CARD_MEMORY_SIZE);
2017-07-07 18:52:51 +08:00
}
void BigBuf_Clear_keep_EM(void) {
2019-03-10 03:34:41 +08:00
memset(BigBuf, 0, BigBuf_hi);
}
// allocate a chunk of memory from BigBuf. We allocate high memory first. The unallocated memory
// at the beginning of BigBuf is always for traces/samples
uint8_t *BigBuf_malloc(uint16_t chunksize) {
2019-03-10 03:34:41 +08:00
if (BigBuf_hi - chunksize < 0)
return NULL; // no memory left
2018-09-05 02:36:25 +08:00
2019-03-10 03:34:41 +08:00
chunksize = (chunksize + 3) & 0xfffc; // round to next multiple of 4
BigBuf_hi -= chunksize; // aligned to 4 Byte boundary
return (uint8_t *)BigBuf + BigBuf_hi;
}
// free ALL allocated chunks. The whole BigBuf is available for traces or samples again.
void BigBuf_free(void) {
2019-03-10 03:34:41 +08:00
BigBuf_hi = BIGBUF_SIZE;
emulator_memory = NULL;
// shouldn't this empty BigBuf also?
}
// free allocated chunks EXCEPT the emulator memory
void BigBuf_free_keep_EM(void) {
2019-03-10 03:34:41 +08:00
if (emulator_memory != NULL)
BigBuf_hi = emulator_memory - (uint8_t *)BigBuf;
else
BigBuf_hi = BIGBUF_SIZE;
2019-03-10 03:34:41 +08:00
// shouldn't this empty BigBuf also?
}
void BigBuf_print_status(void) {
2019-04-30 19:02:27 +08:00
DbpString(_BLUE_("Memory"));
2019-03-10 03:34:41 +08:00
Dbprintf(" BIGBUF_SIZE.............%d", BIGBUF_SIZE);
Dbprintf(" Available memory........%d", BigBuf_hi);
2019-04-30 19:02:27 +08:00
DbpString(_BLUE_("Tracing"));
2019-03-10 03:34:41 +08:00
Dbprintf(" tracing ................%d", tracing);
Dbprintf(" traceLen ...............%d", traceLen);
}
// return the maximum trace length (i.e. the unallocated size of BigBuf)
uint16_t BigBuf_max_traceLen(void) {
2019-03-10 03:34:41 +08:00
return BigBuf_hi;
}
void clear_trace(void) {
2019-03-10 03:34:41 +08:00
traceLen = 0;
}
void set_tracelen(uint32_t value) {
2017-10-24 03:17:59 +08:00
traceLen = value;
}
void set_tracing(bool enable) {
2019-03-10 03:34:41 +08:00
tracing = enable;
}
bool get_tracing(void) {
2019-03-10 03:34:41 +08:00
return tracing;
2017-10-24 03:17:59 +08:00
}
/**
* Get the number of bytes traced
* @return
*/
uint32_t BigBuf_get_traceLen(void) {
2019-03-10 03:34:41 +08:00
return traceLen;
}
/**
This is a function to store traces. All protocols can use this generic tracer-function.
The traces produced by calling this function can be fetched on the client-side
by 'hf list raw', alternatively 'hf list <proto>' for protocol-specific
annotation of commands/responses.
**/
bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag) {
2019-03-10 03:34:41 +08:00
if (!tracing) return false;
uint8_t *trace = BigBuf_get_addr();
2019-03-10 07:00:59 +08:00
uint32_t num_paritybytes = (iLen - 1) / 8 + 1; // number of valid paritybytes in *parity
2019-03-10 03:34:41 +08:00
uint32_t duration = timestamp_end - timestamp_start;
// Return when trace is full
if (traceLen + sizeof(iLen) + sizeof(timestamp_start) + sizeof(duration) + num_paritybytes + iLen >= BigBuf_max_traceLen()) {
tracing = false; // don't trace any more
return false;
}
// Traceformat:
// 32 bits timestamp (little endian)
// 16 bits duration (little endian)
// 16 bits data length (little endian, Highest Bit used as readerToTag flag)
// y Bytes data
// x Bytes parity (one byte per 8 bytes data)
// timestamp (start)
trace[traceLen++] = ((timestamp_start >> 0) & 0xff);
trace[traceLen++] = ((timestamp_start >> 8) & 0xff);
trace[traceLen++] = ((timestamp_start >> 16) & 0xff);
trace[traceLen++] = ((timestamp_start >> 24) & 0xff);
// duration
trace[traceLen++] = ((duration >> 0) & 0xff);
trace[traceLen++] = ((duration >> 8) & 0xff);
// data length
trace[traceLen++] = ((iLen >> 0) & 0xff);
trace[traceLen++] = ((iLen >> 8) & 0xff);
// readerToTag flag
if (!readerToTag) {
trace[traceLen - 1] |= 0x80;
}
// data bytes
if (btBytes != NULL && iLen != 0) {
memcpy(trace + traceLen, btBytes, iLen);
}
traceLen += iLen;
// parity bytes
if (num_paritybytes != 0) {
if (parity != NULL) {
memcpy(trace + traceLen, parity, num_paritybytes);
} else {
memset(trace + traceLen, 0x00, num_paritybytes);
}
}
traceLen += num_paritybytes;
return true;
}
// Emulator memory
uint8_t emlSet(uint8_t *data, uint32_t offset, uint32_t length) {
2019-03-10 07:00:59 +08:00
uint8_t *mem = BigBuf_get_EM_addr();
2019-03-10 03:34:41 +08:00
if (offset + length < CARD_MEMORY_SIZE) {
2019-03-10 07:00:59 +08:00
memcpy(mem + offset, data, length);
2019-03-10 03:34:41 +08:00
return 0;
}
Dbprintf("Error, trying to set memory outside of bounds! %d > %d", (offset + length), CARD_MEMORY_SIZE);
return 1;
}