X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/57c7b44be53a08f355a8978e1db786048c0e8171..c0f15a05b36450c0182462d6d9d093c04c602b67:/client/cmddata.c

diff --git a/client/cmddata.c b/client/cmddata.c
index 7244c614..2c12e2bb 100644
--- a/client/cmddata.c
+++ b/client/cmddata.c
@@ -58,11 +58,12 @@ int CmdSetDebugMode(const char *Cmd)
 }
 
 int usage_data_printdemodbuf(){
-	PrintAndLog("Usage: data printdemodbuffer x o <offset>");
+		PrintAndLog("Usage: data printdemodbuffer x o <offset> l <length>");
 	PrintAndLog("Options:");
 	PrintAndLog("       h          This help");
 	PrintAndLog("       x          output in hex (omit for binary output)");
 	PrintAndLog("       o <offset> enter offset in # of bits");
+		PrintAndLog("       l <length> enter length to print in # of bits or hex characters respectively");
 	return 0;	
 }
 
@@ -87,7 +88,8 @@ int CmdPrintDemodBuff(const char *Cmd)
 	char hex[512]={0x00};
 	bool hexMode = false;
 	bool errors = false;
-	uint8_t offset = 0;
+	uint32_t offset = 0; //could be size_t but no param_get16...
+	uint32_t length = 512;
 	char cmdp = 0;
 	while(param_getchar(Cmd, cmdp) != 0x00)
 	{
@@ -103,10 +105,16 @@ int CmdPrintDemodBuff(const char *Cmd)
 			break;
 		case 'o':
 		case 'O':
-			offset = param_get8(Cmd, cmdp+1);
+			offset = param_get32ex(Cmd, cmdp+1, 0, 10);
 			if (!offset) errors = true;
 			cmdp += 2;
 			break;
+		case 'l':
+		case 'L':
+			length = param_get32ex(Cmd, cmdp+1, 512, 10);
+			if (!length) errors = true;
+			cmdp += 2;
+			break;
 		default:
 			PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
 			errors = true;
@@ -116,18 +124,17 @@ int CmdPrintDemodBuff(const char *Cmd)
 	}
 	//Validations
 	if(errors) return usage_data_printdemodbuf();
-
-	int numBits = (DemodBufferLen-offset) & 0x7FC; //make sure we don't exceed our string
+	length = (length > (DemodBufferLen-offset)) ? DemodBufferLen-offset : length; 
+	int numBits = (length) & 0x00FFC; //make sure we don't exceed our string
 
 	if (hexMode){
 		char *buf = (char *) (DemodBuffer + offset);
+		numBits = (numBits > sizeof(hex)) ? sizeof(hex) : numBits;
 		numBits = binarraytohex(hex, buf, numBits);
 		if (numBits==0) return 0;
 		PrintAndLog("DemodBuffer: %s",hex);		
 	} else {
-		//setDemodBuf(DemodBuffer, DemodBufferLen-offset, offset);
-		char *bin = sprint_bin_break(DemodBuffer+offset,numBits,16);
-		PrintAndLog("DemodBuffer:\n%s",bin);
+		PrintAndLog("DemodBuffer:\n%s", sprint_bin_break(DemodBuffer+offset,numBits,16));
 	}
 	return 1;
 }
@@ -270,7 +277,8 @@ int AskEm410xDecode(bool verbose, uint32_t *hi, uint64_t *lo )
 
 int AskEm410xDemod(const char *Cmd, uint32_t *hi, uint64_t *lo, bool verbose)
 {
-	if (!ASKDemod(Cmd, FALSE, FALSE, 1)) return 0;
+	bool st = TRUE;
+	if (!ASKDemod_ext(Cmd, FALSE, FALSE, 1, &st)) return 0;
 	return AskEm410xDecode(verbose, hi, lo);
 }
 
@@ -305,8 +313,7 @@ int CmdAskEM410xDemod(const char *Cmd)
 //verbose will print results and demoding messages
 //emSearch will auto search for EM410x format in bitstream
 //askType switches decode: ask/raw = 0, ask/manchester = 1 
-int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
-{
+int ASKDemod_ext(const char *Cmd, bool verbose, bool emSearch, uint8_t askType, bool *stCheck) {
 	int invert=0;
 	int clk=0;
 	int maxErr=100;
@@ -315,7 +322,7 @@ int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
 	char amp = param_getchar(Cmd, 0);
 	uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 	sscanf(Cmd, "%i %i %i %i %c", &clk, &invert, &maxErr, &maxLen, &amp);
-	if (!maxLen) maxLen = 512*64;
+	if (!maxLen) maxLen = BIGBUF_SIZE;
 	if (invert != 0 && invert != 1) {
 		PrintAndLog("Invalid argument: %s", Cmd);
 		return 0;
@@ -329,7 +336,14 @@ int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
 	if (g_debugMode) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
 	if (BitLen<255) return 0;
 	if (maxLen<BitLen && maxLen != 0) BitLen = maxLen;
-
+	int foundclk = 0;
+	bool st = false;
+	if (*stCheck) st = DetectST(BitStream, &BitLen, &foundclk);
+	if (st) {
+		*stCheck = st;
+		clk = (clk == 0) ? foundclk : clk;
+		if (verbose || g_debugMode) PrintAndLog("\nFound Sequence Terminator");
+	}
 	int errCnt = askdemod(BitStream, &BitLen, &clk, &invert, maxErr, askAmp, askType);
 	if (errCnt<0 || BitLen<16){  //if fatal error (or -1)
 		if (g_debugMode) PrintAndLog("DEBUG: no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
@@ -358,6 +372,10 @@ int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType)
 	}
 	return 1;
 }
+int ASKDemod(const char *Cmd, bool verbose, bool emSearch, uint8_t askType) {
+	bool st = false;
+	return ASKDemod_ext(Cmd, verbose, emSearch, askType, &st);
+}
 
 //by marshmellow
 //takes 5 arguments - clock, invert, maxErr, maxLen as integers and amplify as char == 'a'
@@ -367,7 +385,8 @@ int Cmdaskmandemod(const char *Cmd)
 {
 	char cmdp = param_getchar(Cmd, 0);
 	if (strlen(Cmd) > 25 || cmdp == 'h' || cmdp == 'H') {
-		PrintAndLog("Usage:  data rawdemod am [clock] <invert> [maxError] [maxLen] [amplify]");
+		PrintAndLog("Usage:  data rawdemod am <s> [clock] <invert> [maxError] [maxLen] [amplify]");
+		PrintAndLog("     ['s'] optional, check for Sequence Terminator");
 		PrintAndLog("     [set clock as integer] optional, if not set, autodetect");
 		PrintAndLog("     <invert>, 1 to invert output");
 		PrintAndLog("     [set maximum allowed errors], default = 100");
@@ -381,6 +400,12 @@ int Cmdaskmandemod(const char *Cmd)
 		PrintAndLog("          : data rawdemod am 64 1 0 = demod an ask/manchester tag from GraphBuffer using a clock of RF/64, inverting data and allowing 0 demod errors");
 		return 0;
 	}
+	bool st = TRUE;
+	if (Cmd[0]=='s') 
+		return ASKDemod_ext(Cmd++, TRUE, TRUE, 1, &st);
+	else if (Cmd[1] == 's')
+		return ASKDemod_ext(Cmd+=2, TRUE, TRUE, 1, &st);
+	else
 	return ASKDemod(Cmd, TRUE, TRUE, 1);
 }
 
@@ -588,7 +613,7 @@ int CmdG_Prox_II_Demod(const char *Cmd)
 		if ((idx+1) % 5 == 0){
 			//spacer bit - should be 0
 			if (DemodBuffer[startIdx+idx] != 0) {
-				if (g_debugMode) PrintAndLog("Error spacer not 0: %d, pos: %d",DemodBuffer[startIdx+idx],startIdx+idx);
+				if (g_debugMode) PrintAndLog("Error spacer not 0: %u, pos: %u", (unsigned int)DemodBuffer[startIdx+idx],(unsigned int)(startIdx+idx));
 				return 0;
 			}
 			continue;
@@ -603,14 +628,14 @@ int CmdG_Prox_II_Demod(const char *Cmd)
 		ByteStream[ByteCnt] = ByteStream[ByteCnt] | (DemodBuffer[startIdx+idx]<<bitCnt);
 		bitCnt++;
 		if (bitCnt % 8 == 0){
-			if (g_debugMode) PrintAndLog("byte %d: %02x",ByteCnt,ByteStream[ByteCnt]);
+			if (g_debugMode) PrintAndLog("byte %u: %02x", (unsigned int)ByteCnt, ByteStream[ByteCnt]);
 			bitCnt=0;
 			ByteCnt++;
 		}
 	}
 	for (uint8_t i = 0; i < ByteCnt; i++){
 		ByteStream[i] ^= xorKey; //xor
-		if (g_debugMode) PrintAndLog("byte %d after xor: %02x", i, ByteStream[i]);
+		if (g_debugMode) PrintAndLog("byte %u after xor: %02x", (unsigned int)i, ByteStream[i]);
 	}
 	//now ByteStream contains 64 bytes of decrypted raw tag data
 	// 
@@ -637,6 +662,32 @@ int CmdG_Prox_II_Demod(const char *Cmd)
 	return 1;
 }
 
+//by marshmellow
+//see ASKDemod for what args are accepted
+int CmdVikingDemod(const char *Cmd)
+{
+	if (!ASKDemod(Cmd, false, false, 1)) {
+		if (g_debugMode) PrintAndLog("ASKDemod failed");
+		return 0;
+	}
+	size_t size = DemodBufferLen;
+	//call lfdemod.c demod for Viking
+	int ans = VikingDemod_AM(DemodBuffer, &size);
+	if (ans < 0) {
+		if (g_debugMode) PrintAndLog("Error Viking_Demod %d", ans);
+		return 0;
+	}
+	//got a good demod
+	uint32_t raw1 = bytebits_to_byte(DemodBuffer+ans, 32);
+	uint32_t raw2 = bytebits_to_byte(DemodBuffer+ans+32, 32);
+	uint32_t cardid = bytebits_to_byte(DemodBuffer+ans+24, 32);
+	uint8_t  checksum = bytebits_to_byte(DemodBuffer+ans+32+24, 8);
+	PrintAndLog("Viking Tag Found: Card ID %08X, Checksum: %02X", cardid, checksum);
+	PrintAndLog("Raw: %08X%08X", raw1,raw2);
+	setDemodBuf(DemodBuffer+ans, 64, 0);
+	return 1;
+}
+
 //by marshmellow - see ASKDemod
 int Cmdaskrawdemod(const char *Cmd)
 {
@@ -794,19 +845,20 @@ int CmdUndec(const char *Cmd)
 		return 0;
 	}
 
-	uint8_t factor = param_get8ex(Cmd, 0,2, 10);
+	uint8_t factor = param_get8ex(Cmd, 0, 2, 10);
 	//We have memory, don't we?
 	int swap[MAX_GRAPH_TRACE_LEN] = { 0 };
 	uint32_t g_index = 0 ,s_index = 0;
-	while(g_index < GraphTraceLen && s_index < MAX_GRAPH_TRACE_LEN)
+	while(g_index < GraphTraceLen && s_index + factor < MAX_GRAPH_TRACE_LEN)
 	{
 		int count = 0;
-		for(count = 0; count < factor && s_index+count < MAX_GRAPH_TRACE_LEN; count ++)
+		for (count = 0; count < factor && s_index + count < MAX_GRAPH_TRACE_LEN; count++)
 			swap[s_index+count] = GraphBuffer[g_index];
-		s_index+=count;
+		s_index += count;
+		g_index++;
 	}
 
-	memcpy(GraphBuffer,swap, s_index * sizeof(int));
+	memcpy(GraphBuffer, swap, s_index * sizeof(int));
 	GraphTraceLen = s_index;
 	RepaintGraphWindow();
 	return 0;
@@ -886,19 +938,21 @@ int CmdDetectClockRate(const char *Cmd)
 
 char *GetFSKType(uint8_t fchigh, uint8_t fclow, uint8_t invert)
 {
-	char *fskType;
+	static char fType[8];
+	memset(fType, 0x00, 8);	
+	char *fskType = fType;
 	if (fchigh==10 && fclow==8){
 		if (invert) //fsk2a
-			fskType = "FSK2a";
+			memcpy(fskType, "FSK2a", 5);
 		else //fsk2
-			fskType = "FSK2";
+			memcpy(fskType, "FSK2", 4);
 	} else if (fchigh == 8 && fclow == 5) {
 		if (invert)
-			fskType = "FSK1";
+			memcpy(fskType, "FSK1", 4);
 		else
-			fskType = "FSK1a";
+			memcpy(fskType, "FSK1a", 5);
 	} else {
-		fskType = "FSK??";
+		memcpy(fskType, "FSK??", 5);
 	}
 	return fskType;
 }
@@ -910,20 +964,19 @@ char *GetFSKType(uint8_t fchigh, uint8_t fclow, uint8_t invert)
 int FSKrawDemod(const char *Cmd, bool verbose)
 {
 	//raw fsk demod  no manchester decoding no start bit finding just get binary from wave
-	//set defaults
-	int rfLen = 0;
-	int invert = 0;
-	int fchigh = 0;
-	int fclow = 0;
+	uint8_t rfLen, invert, fchigh, fclow;
 
+	//set defaults
 	//set options from parameters entered with the command
-	sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
-
+	rfLen = param_get8(Cmd, 0);
+	invert = param_get8(Cmd, 1);
+	fchigh = param_get8(Cmd, 2);
+	fclow = param_get8(Cmd, 3);
 	if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
-		 if (rfLen==1){
+		if (rfLen==1) {
 			invert = 1;   //if invert option only is used
 			rfLen = 0;
-		 }
+		}
 	}
 
 	uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
@@ -931,34 +984,34 @@ int FSKrawDemod(const char *Cmd, bool verbose)
 	if (BitLen==0) return 0;
 	//get field clock lengths
 	uint16_t fcs=0;
-	if (fchigh==0 || fclow == 0){
+	if (!fchigh || !fclow) {
 		fcs = countFC(BitStream, BitLen, 1);
-		if (fcs==0){
-			fchigh=10;
-			fclow=8;
-		}else{
-			fchigh = (fcs >> 8) & 0xFF;
-			fclow = fcs & 0xFF;
+		if (!fcs) {
+			fchigh = 10;
+			fclow = 8;
+		} else {
+			fchigh = (fcs >> 8) & 0x00FF;
+			fclow = fcs & 0x00FF;
 		}
 	}
 	//get bit clock length
-	if (rfLen==0){
+	if (!rfLen) {
 		rfLen = detectFSKClk(BitStream, BitLen, fchigh, fclow);
-		if (rfLen == 0) rfLen = 50;
+		if (!rfLen) rfLen = 50;
 	}
-	int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow);
-	if (size>0){
-		setDemodBuf(BitStream,size,0);
+	int size = fskdemod(BitStream, BitLen, rfLen, invert, fchigh, fclow);
+	if (size > 0) {
+		setDemodBuf(BitStream, size, 0);
 
 		// Now output the bitstream to the scrollback by line of 16 bits
 		if (verbose || g_debugMode) {
-			PrintAndLog("\nUsing Clock:%d, invert:%d, fchigh:%d, fclow:%d", rfLen, invert, fchigh, fclow);
-			PrintAndLog("%s decoded bitstream:",GetFSKType(fchigh,fclow,invert));
+			PrintAndLog("\nUsing Clock:%u, invert:%u, fchigh:%u, fclow:%u", (unsigned int)rfLen,  (unsigned int)invert,  (unsigned int)fchigh,  (unsigned int)fclow);
+			PrintAndLog("%s decoded bitstream:", GetFSKType(fchigh, fclow, invert));
 			printDemodBuff();
 		}
 
 		return 1;
-	} else{
+	} else {
 		if (g_debugMode) PrintAndLog("no FSK data found");
 	}
 	return 0;
@@ -1130,8 +1183,6 @@ int CmdFSKdemodParadox(const char *Cmd)
 //print ioprox ID and some format details
 int CmdFSKdemodIO(const char *Cmd)
 {
-	//raw fsk demod no manchester decoding no start bit finding just get binary from wave
-	//set defaults
 	int idx=0;
 	//something in graphbuffer?
 	if (GraphTraceLen < 65) {
@@ -1220,7 +1271,6 @@ int CmdFSKdemodIO(const char *Cmd)
 //print full AWID Prox ID and some bit format details if found
 int CmdFSKdemodAWID(const char *Cmd)
 {
-	//raw fsk demod no manchester decoding no start bit finding just get binary from wave
 	uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
 	size_t size = getFromGraphBuf(BitStream);
 	if (size==0) return 0;
@@ -1495,6 +1545,10 @@ int CmdFDXBdemodBI(const char *Cmd){
 		if (g_debugMode) PrintAndLog("Error FDXBDemod , no startmarker found :: %d",preambleIndex);
 		return 0;
 	}
+	if (size != 128) {
+		if (g_debugMode) PrintAndLog("Error incorrect data length found");
+		return 0;
+	}
 	
 	setDemodBuf(BitStream, 128, preambleIndex);
 
@@ -1564,6 +1618,9 @@ int PSKDemod(const char *Cmd, bool verbose)
 		//invalid carrier
 		return 0;
 	}
+	if (g_debugMode){
+		PrintAndLog("Carrier: rf/%d",carrier);
+	}
 	int errCnt=0;
 	errCnt = pskRawDemod(BitStream, &BitLen, &clk, &invert);
 	if (errCnt > maxErr){
@@ -1605,7 +1662,7 @@ int CmdIndalaDecode(const char *Cmd)
 	uint8_t invert=0;
 	size_t size = DemodBufferLen;
 	size_t startIdx = indala26decode(DemodBuffer, &size, &invert);
-	if (startIdx < 1) {
+	if (startIdx < 1 || size > 224) {
 		if (g_debugMode==1)
 			PrintAndLog("Error2: %d",ans);
 		return -1;
@@ -1621,15 +1678,15 @@ int CmdIndalaDecode(const char *Cmd)
 	uid1=bytebits_to_byte(DemodBuffer,32);
 	uid2=bytebits_to_byte(DemodBuffer+32,32);
 	if (DemodBufferLen==64){
-		PrintAndLog("Indala UID=%s (%x%08x)", sprint_bin(DemodBuffer,DemodBufferLen), uid1, uid2);
-			} else {
+		PrintAndLog("Indala UID=%s (%x%08x)",  sprint_bin_break(DemodBuffer,DemodBufferLen,16), uid1, uid2);
+	} else {
 		uid3=bytebits_to_byte(DemodBuffer+64,32);
 		uid4=bytebits_to_byte(DemodBuffer+96,32);
 		uid5=bytebits_to_byte(DemodBuffer+128,32);
 		uid6=bytebits_to_byte(DemodBuffer+160,32);
 		uid7=bytebits_to_byte(DemodBuffer+192,32);
 		PrintAndLog("Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)", 
-		    sprint_bin(DemodBuffer,DemodBufferLen), uid1, uid2, uid3, uid4, uid5, uid6, uid7);
+		     sprint_bin_break(DemodBuffer,DemodBufferLen,16), uid1, uid2, uid3, uid4, uid5, uid6, uid7);
 	}
 	if (g_debugMode){
 		PrintAndLog("DEBUG: printing demodbuffer:");
@@ -1699,7 +1756,7 @@ int NRZrawDemod(const char *Cmd, bool verbose)
 	size_t BitLen = getFromGraphBuf(BitStream);
 	if (BitLen==0) return 0;
 	int errCnt=0;
-	errCnt = nrzRawDemod(BitStream, &BitLen, &clk, &invert, maxErr);
+	errCnt = nrzRawDemod(BitStream, &BitLen, &clk, &invert);
 	if (errCnt > maxErr){
 		if (g_debugMode) PrintAndLog("Too many errors found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
 		return 0;
@@ -1952,25 +2009,25 @@ int getSamples(const char *Cmd, bool silent)
 
 	int n = strtol(Cmd, NULL, 0);
 
-	if (n == 0)
-		n = sizeof(got);
-
-	if (n > sizeof(got))
+	if ( n == 0 || n > sizeof(got))
 		n = sizeof(got);
 
 	PrintAndLog("Reading %d bytes from device memory\n", n);
 	GetFromBigBuf(got,n,0);
 	PrintAndLog("Data fetched");
 	UsbCommand response;
-	WaitForResponse(CMD_ACK, &response);
+	if ( !WaitForResponseTimeout(CMD_ACK, &response, 10000) ) {
+        PrintAndLog("timeout while waiting for reply.");
+		return 1;
+    }
+	
 	uint8_t bits_per_sample = 8;
 
 	//Old devices without this feature would send 0 at arg[0]
 	if(response.arg[0] > 0)
 	{
 		sample_config *sc = (sample_config *) response.d.asBytes;
-		PrintAndLog("Samples @ %d bits/smpl, decimation 1:%d ", sc->bits_per_sample
-		    , sc->decimation);
+		PrintAndLog("Samples @ %d bits/smpl, decimation 1:%d ", sc->bits_per_sample, sc->decimation);
 		bits_per_sample = sc->bits_per_sample;
 	}
 	if(bits_per_sample < 8)
@@ -2006,11 +2063,11 @@ int CmdTuneSamples(const char *Cmd)
 	int timeout = 0;
 	printf("\nMeasuring antenna characteristics, please wait...");
 
-	UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING};
+	UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING, {0,0,0}};
+	clearCommandBuffer();
 	SendCommand(&c);
-
 	UsbCommand resp;
-	while(!WaitForResponseTimeout(CMD_MEASURED_ANTENNA_TUNING,&resp,1000)) {
+	while(!WaitForResponseTimeout(CMD_MEASURED_ANTENNA_TUNING, &resp, 2000)) {
 		timeout++;
 		printf(".");
 		if (timeout > 7) {
@@ -2056,7 +2113,6 @@ int CmdTuneSamples(const char *Cmd)
 		ShowGraphWindow();
 		RepaintGraphWindow();
 	}
-
 	return 0;
 }
 
@@ -2072,7 +2128,7 @@ int CmdLoad(const char *Cmd)
 	
 	FILE *f = fopen(filename, "r");
 	if (!f) {
-		 PrintAndLog("couldn't open '%s'", filename);
+		PrintAndLog("couldn't open '%s'", filename);
 		return 0;
 	}
 
@@ -2091,11 +2147,13 @@ int CmdLoad(const char *Cmd)
 int CmdLtrim(const char *Cmd)
 {
 	int ds = atoi(Cmd);
-	if (GraphTraceLen<=0) return 0;
+
+	if (GraphTraceLen <= 0) return 0;
+
 	for (int i = ds; i < GraphTraceLen; ++i)
 		GraphBuffer[i-ds] = GraphBuffer[i];
-	GraphTraceLen -= ds;
 
+	GraphTraceLen -= ds;
 	RepaintGraphWindow();
 	return 0;
 }
@@ -2104,9 +2162,7 @@ int CmdLtrim(const char *Cmd)
 int CmdRtrim(const char *Cmd)
 {
 	int ds = atoi(Cmd);
-
 	GraphTraceLen = ds;
-
 	RepaintGraphWindow();
 	return 0;
 }
@@ -2290,21 +2346,15 @@ int Cmdbin2hex(const char *Cmd)
 }
 
 int usage_data_hex2bin(){
-
-	PrintAndLog("Usage: data bin2hex <binary_digits>");
+	PrintAndLog("Usage: data hex2bin <hex_digits>");
 	PrintAndLog("       This function will ignore all non-hexadecimal characters (but stop reading on whitespace)");
 	return 0;
-
 }
 
 int Cmdhex2bin(const char *Cmd)
 {
 	int bg =0, en =0;
-	if(param_getptr(Cmd, &bg, &en, 0))
-	{
-		return usage_data_hex2bin();
-	}
-
+	if(param_getptr(Cmd, &bg, &en, 0))  return usage_data_hex2bin();
 
 	while(bg <= en )
 	{
@@ -2365,14 +2415,14 @@ static command_t CommandTable[] =
 	{"manrawdecode",    Cmdmandecoderaw,    1, "[invert] [maxErr] -- Manchester decode binary stream in DemodBuffer"},
 	{"norm",            CmdNorm,            1, "Normalize max/min to +/-128"},
 	{"plot",            CmdPlot,            1, "Show graph window (hit 'h' in window for keystroke help)"},
-	{"printdemodbuffer",CmdPrintDemodBuff,  1, "[x] [o] <offset> -- print the data in the DemodBuffer - 'x' for hex output"},
+	{"printdemodbuffer",CmdPrintDemodBuff,  1, "[x] [o] <offset> [l] <length> -- print the data in the DemodBuffer - 'x' for hex output"},
 	{"pskindalademod",  CmdIndalaDecode,    1, "[clock] [invert<0|1>] -- Demodulate an indala tag (PSK1) from GraphBuffer (args optional)"},
 	{"psknexwatchdemod",CmdPSKNexWatch,     1, "Demodulate a NexWatch tag (nexkey, quadrakey) (PSK1) from GraphBuffer"},
 	{"rawdemod",        CmdRawDemod,        1, "[modulation] ... <options> -see help (h option) -- Demodulate the data in the GraphBuffer and output binary"},  
 	{"samples",         CmdSamples,         0, "[512 - 40000] -- Get raw samples for graph window (GraphBuffer)"},
 	{"save",            CmdSave,            1, "<filename> -- Save trace (from graph window)"},
 	{"scale",           CmdScale,           1, "<int> -- Set cursor display scale"},
-	{"setdebugmode",    CmdSetDebugMode,    1, "<0|1> -- Turn on or off Debugging Mode for demods"},
+	{"setdebugmode",    CmdSetDebugMode,    1, "<0|1|2> -- Turn on or off Debugging Level for lf demods"},
 	{"shiftgraphzero",  CmdGraphShiftZero,  1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
 	{"dirthreshold",    CmdDirectionalThreshold,   1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
 	{"tune",            CmdTuneSamples,     0, "Get hw tune samples for graph window"},
@@ -2381,8 +2431,8 @@ static command_t CommandTable[] =
 	{NULL, NULL, 0, NULL}
 };
 
-int CmdData(const char *Cmd)
-{
+int CmdData(const char *Cmd){
+	clearCommandBuffer();
 	CmdsParse(CommandTable, Cmd);
 	return 0;
 }