]> git.zerfleddert.de Git - proxmark3-svn/blob - armsrc/BigBuf.c
CHG: removed a -L path for OSX
[proxmark3-svn] / armsrc / BigBuf.c
1 //-----------------------------------------------------------------------------
2 // Jonathan Westhues, Aug 2005
3 // Gerhard de Koning Gans, April 2008, May 2011
4 //
5 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
6 // at your option, any later version. See the LICENSE.txt file for the text of
7 // the license.
8 //-----------------------------------------------------------------------------
9 // BigBuf and functions to allocate/free parts of it.
10 //-----------------------------------------------------------------------------
11 #include "BigBuf.h"
12
13 // BigBuf is the large multi-purpose buffer, typically used to hold A/D samples or traces.
14 // Also used to hold various smaller buffers and the Mifare Emulator Memory.
15 // declare it as uint32_t to achieve alignment to 4 Byte boundary
16 static uint32_t BigBuf[BIGBUF_SIZE/sizeof(uint32_t)];
17
18 /* BigBuf memory layout:
19 Pointer to highest available memory: BigBuf_hi
20
21 high BIGBUF_SIZE
22 reserved = BigBuf_malloc() subtracts amount from BigBuf_hi,
23 low 0x00
24 */
25
26 // High memory mark
27 static uint16_t BigBuf_hi = BIGBUF_SIZE;
28
29 // pointer to the emulator memory.
30 static uint8_t *emulator_memory = NULL;
31
32 // trace related variables
33 static uint16_t traceLen = 0;
34 int tracing = 1; //Last global one.. todo static?
35
36 // get the address of BigBuf
37 uint8_t *BigBuf_get_addr(void)
38 {
39 return (uint8_t *)BigBuf;
40 }
41
42 // get the address of the emulator memory. Allocate part of Bigbuf for it, if not yet done
43 uint8_t *BigBuf_get_EM_addr(void)
44 {
45 // not yet allocated
46 if (emulator_memory == NULL)
47 emulator_memory = BigBuf_malloc(CARD_MEMORY_SIZE);
48
49 return emulator_memory;
50 }
51
52 // clear ALL of BigBuf
53 void BigBuf_Clear(void)
54 {
55 BigBuf_Clear_ext(true);
56 }
57
58 // clear ALL of BigBuf
59 void BigBuf_Clear_ext(bool verbose)
60 {
61 memset(BigBuf, 0, BIGBUF_SIZE);
62 if (verbose)
63 Dbprintf("Buffer cleared (%i bytes)", BIGBUF_SIZE);
64 }
65
66 void BigBuf_Clear_keep_EM(void)
67 {
68 memset(BigBuf, 0, BigBuf_hi);
69 }
70
71 // allocate a chunk of memory from BigBuf. We allocate high memory first. The unallocated memory
72 // at the beginning of BigBuf is always for traces/samples
73 uint8_t *BigBuf_malloc(uint16_t chunksize)
74 {
75 if (BigBuf_hi - chunksize < 0) {
76 return NULL; // no memory left
77 } else {
78 chunksize = (chunksize + 3) & 0xfffc; // round to next multiple of 4
79 BigBuf_hi -= chunksize; // aligned to 4 Byte boundary
80 return (uint8_t *)BigBuf + BigBuf_hi;
81 }
82 }
83
84 // free ALL allocated chunks. The whole BigBuf is available for traces or samples again.
85 void BigBuf_free(void)
86 {
87 BigBuf_hi = BIGBUF_SIZE;
88 emulator_memory = NULL;
89
90 // shouldn't this empty BigBuf also?
91 }
92
93 // free allocated chunks EXCEPT the emulator memory
94 void BigBuf_free_keep_EM(void)
95 {
96 if (emulator_memory != NULL)
97 BigBuf_hi = emulator_memory - (uint8_t *)BigBuf;
98 else
99 BigBuf_hi = BIGBUF_SIZE;
100
101 // shouldn't this empty BigBuf also?
102 }
103
104 void BigBuf_print_status(void)
105 {
106 Dbprintf("Memory");
107 Dbprintf(" BIGBUF_SIZE.............%d", BIGBUF_SIZE);
108 Dbprintf(" Available memory........%d", BigBuf_hi);
109 Dbprintf("Tracing");
110 Dbprintf(" tracing ................%d", tracing);
111 Dbprintf(" traceLen ...............%d", traceLen);
112 }
113
114 // return the maximum trace length (i.e. the unallocated size of BigBuf)
115 uint16_t BigBuf_max_traceLen(void)
116 {
117 return BigBuf_hi;
118 }
119
120 void clear_trace() {
121 traceLen = 0;
122 }
123
124 void set_tracing(bool enable) {
125 tracing = enable;
126 }
127
128 /**
129 * Get the number of bytes traced
130 * @return
131 */
132 uint16_t BigBuf_get_traceLen(void)
133 {
134 return traceLen;
135 }
136
137 /**
138 This is a function to store traces. All protocols can use this generic tracer-function.
139 The traces produced by calling this function can be fetched on the client-side
140 by 'hf list raw', alternatively 'hf list <proto>' for protocol-specific
141 annotation of commands/responses.
142 **/
143 bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag)
144 {
145 if (!tracing) return FALSE;
146
147 uint8_t *trace = BigBuf_get_addr();
148
149 uint16_t num_paritybytes = (iLen-1)/8 + 1; // number of valid paritybytes in *parity
150 uint16_t duration = timestamp_end - timestamp_start;
151
152 // Return when trace is full
153 if (traceLen + sizeof(iLen) + sizeof(timestamp_start) + sizeof(duration) + num_paritybytes + iLen >= BigBuf_max_traceLen()) {
154 tracing = FALSE; // don't trace any more
155 return FALSE;
156 }
157 // Traceformat:
158 // 32 bits timestamp (little endian)
159 // 16 bits duration (little endian)
160 // 16 bits data length (little endian, Highest Bit used as readerToTag flag)
161 // y Bytes data
162 // x Bytes parity (one byte per 8 bytes data)
163
164 // timestamp (start)
165 trace[traceLen++] = ((timestamp_start >> 0) & 0xff);
166 trace[traceLen++] = ((timestamp_start >> 8) & 0xff);
167 trace[traceLen++] = ((timestamp_start >> 16) & 0xff);
168 trace[traceLen++] = ((timestamp_start >> 24) & 0xff);
169
170 // duration
171 trace[traceLen++] = ((duration >> 0) & 0xff);
172 trace[traceLen++] = ((duration >> 8) & 0xff);
173
174 // data length
175 trace[traceLen++] = ((iLen >> 0) & 0xff);
176 trace[traceLen++] = ((iLen >> 8) & 0xff);
177
178 // readerToTag flag
179 if (!readerToTag) {
180 trace[traceLen - 1] |= 0x80;
181 }
182
183 // data bytes
184 if (btBytes != NULL && iLen != 0) {
185 memcpy(trace + traceLen, btBytes, iLen);
186 }
187 traceLen += iLen;
188
189 // parity bytes
190 if (num_paritybytes != 0) {
191 if (parity != NULL) {
192 memcpy(trace + traceLen, parity, num_paritybytes);
193 } else {
194 memset(trace + traceLen, 0x00, num_paritybytes);
195 }
196 }
197 traceLen += num_paritybytes;
198
199 return TRUE;
200 }
201
202
203 int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwParity, int readerToTag)
204 {
205 /**
206 Todo, rewrite the logger to use the generic functionality instead. It should be noted, however,
207 that this logger takes number of bits as argument, not number of bytes.
208 **/
209
210 if (!tracing) return FALSE;
211
212 uint8_t *trace = BigBuf_get_addr();
213 uint16_t iLen = nbytes(iBits);
214 // Return when trace is full
215 if (traceLen + sizeof(rsamples) + sizeof(dwParity) + sizeof(iBits) + iLen > BigBuf_max_traceLen()) return FALSE;
216
217 //Hitag traces appear to use this traceformat:
218 // 32 bits timestamp (little endian,Highest Bit used as readerToTag flag)
219 // 32 bits parity
220 // 8 bits size (number of bits in the trace entry, not number of bytes)
221 // y Bytes data
222
223 rsamples += iSamples;
224 trace[traceLen++] = ((rsamples >> 0) & 0xff);
225 trace[traceLen++] = ((rsamples >> 8) & 0xff);
226 trace[traceLen++] = ((rsamples >> 16) & 0xff);
227 trace[traceLen++] = ((rsamples >> 24) & 0xff);
228
229 if (!readerToTag) {
230 trace[traceLen - 1] |= 0x80;
231 }
232
233 trace[traceLen++] = ((dwParity >> 0) & 0xff);
234 trace[traceLen++] = ((dwParity >> 8) & 0xff);
235 trace[traceLen++] = ((dwParity >> 16) & 0xff);
236 trace[traceLen++] = ((dwParity >> 24) & 0xff);
237 trace[traceLen++] = iBits;
238
239 memcpy(trace + traceLen, btBytes, iLen);
240 traceLen += iLen;
241
242 return TRUE;
243 }
244
245
246 // Emulator memory
247 uint8_t emlSet(uint8_t *data, uint32_t offset, uint32_t length){
248 uint8_t* mem = BigBuf_get_EM_addr();
249 if(offset+length < CARD_MEMORY_SIZE) {
250 memcpy(mem+offset, data, length);
251 return 0;
252 } else {
253 Dbprintf("Error, trying to set memory outside of bounds! %d > %d", (offset+length), CARD_MEMORY_SIZE);
254 return 1;
255 }
256 }
Impressum, Datenschutz