X-Git-Url: http://cvs.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/665775c844a3f8f1efe055cd25462b3cd7a7441a..e7f43e92e9b8a8afe7aa235a34a70af59e8e6cea:/armsrc/BigBuf.c diff --git a/armsrc/BigBuf.c b/armsrc/BigBuf.c index 6e99a793..cf0c26b2 100644 --- a/armsrc/BigBuf.c +++ b/armsrc/BigBuf.c @@ -8,18 +8,21 @@ //----------------------------------------------------------------------------- // BigBuf and functions to allocate/free parts of it. //----------------------------------------------------------------------------- - -#include -#include "proxmark3.h" -#include "apps.h" -#include "string.h" +#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 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, + low 0x00 +*/ + // High memory mark static uint16_t BigBuf_hi = BIGBUF_SIZE; @@ -36,25 +39,34 @@ uint8_t *BigBuf_get_addr(void) 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) { - if (emulator_memory == NULL) { // not yet allocated + // not yet allocated + if (emulator_memory == NULL) emulator_memory = BigBuf_malloc(CARD_MEMORY_SIZE); - } return emulator_memory; } - // clear ALL of BigBuf void BigBuf_Clear(void) { - memset(BigBuf,0,BIGBUF_SIZE); - Dbprintf("Buffer cleared (%i bytes)",BIGBUF_SIZE); + BigBuf_Clear_ext(true); } +// clear ALL of BigBuf +void BigBuf_Clear_ext(bool verbose) +{ + memset(BigBuf, 0, BIGBUF_SIZE); + if (verbose) + Dbprintf("Buffer cleared (%i bytes)", BIGBUF_SIZE); +} + +void BigBuf_Clear_keep_EM(void) +{ + 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 @@ -69,25 +81,35 @@ uint8_t *BigBuf_malloc(uint16_t chunksize) } } - // free ALL allocated chunks. The whole BigBuf is available for traces or samples again. void BigBuf_free(void) { 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) { - if (emulator_memory != NULL) { + if (emulator_memory != NULL) BigBuf_hi = emulator_memory - (uint8_t *)BigBuf; - } else { + else BigBuf_hi = BIGBUF_SIZE; - } + + // shouldn't this empty BigBuf also? } +void BigBuf_print_status(void) +{ + Dbprintf("Memory"); + Dbprintf(" BIGBUF_SIZE.............%d", BIGBUF_SIZE); + Dbprintf(" Available memory........%d", BigBuf_hi); + Dbprintf("Tracing"); + 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) @@ -96,9 +118,6 @@ uint16_t BigBuf_max_traceLen(void) } void clear_trace() { - uint8_t *trace = BigBuf_get_addr(); - uint16_t max_traceLen = BigBuf_max_traceLen(); - memset(trace, 0x44, max_traceLen); traceLen = 0; } @@ -120,7 +139,6 @@ uint16_t BigBuf_get_traceLen(void) The traces produced by calling this function can be fetched on the client-side by 'hf list raw', alternatively 'hf list ' 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) { @@ -132,9 +150,7 @@ bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_ uint16_t duration = timestamp_end - timestamp_start; // Return when trace is full - uint16_t max_traceLen = BigBuf_max_traceLen(); - - if (traceLen + sizeof(iLen) + sizeof(timestamp_start) + sizeof(duration) + num_paritybytes + iLen >= max_traceLen) { + if (traceLen + sizeof(iLen) + sizeof(timestamp_start) + sizeof(duration) + num_paritybytes + iLen >= BigBuf_max_traceLen()) { tracing = FALSE; // don't trace any more return FALSE; } @@ -171,20 +187,25 @@ bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_ traceLen += iLen; // parity bytes - if (parity != NULL && iLen != 0) { - memcpy(trace + traceLen, parity, num_paritybytes); + if (num_paritybytes != 0) { + if (parity != NULL) { + memcpy(trace + traceLen, parity, num_paritybytes); + } else { + memset(trace + traceLen, 0x00, num_paritybytes); + } } traceLen += num_paritybytes; - if(traceLen +4 < max_traceLen) - { //If it hadn't been cleared, for whatever reason.. - memset(trace+traceLen,0x44, 4); - } - return TRUE; } -int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwParity, int bReader) + + +int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwParity, int readerToTag) { + /** + Todo, rewrite the logger to use the generic functionality instead. It should be noted, however, + that this logger takes number of bits as argument, not number of bytes. + **/ if (!tracing) return FALSE; @@ -196,7 +217,7 @@ int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwP //Hitag traces appear to use this traceformat: // 32 bits timestamp (little endian,Highest Bit used as readerToTag flag) // 32 bits parity - // 8 bits size (number of bits in the trace entry) + // 8 bits size (number of bits in the trace entry, not number of bytes) // y Bytes data rsamples += iSamples; @@ -205,7 +226,7 @@ int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwP trace[traceLen++] = ((rsamples >> 16) & 0xff); trace[traceLen++] = ((rsamples >> 24) & 0xff); - if (!bReader) { + if (!readerToTag) { trace[traceLen - 1] |= 0x80; } @@ -220,3 +241,16 @@ int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwP return TRUE; } + + +// Emulator memory +uint8_t emlSet(uint8_t *data, uint32_t offset, uint32_t length){ + uint8_t* mem = BigBuf_get_EM_addr(); + if(offset+length < CARD_MEMORY_SIZE) { + memcpy(mem+offset, data, length); + return 0; + } else { + Dbprintf("Error, trying to set memory outside of bounds! %d > %d", (offset+length), CARD_MEMORY_SIZE); + return 1; + } +}