git.zerfleddert.de Git - proxmark3-svn/blobdiff

index d994f2e5d8aeb6e1ae0e6f2ec98cb71716778ad6..719617fde62ea63d42939e2f8917c15a18661ac8 100644 (file)

--- a/client/cmdmain.c

+++ b/client/cmdmain.c

@@ -8,11 +8,13 @@

// Main command parser entry point

//-----------------------------------------------------------------------------

// Main command parser entry point

//-----------------------------------------------------------------------------

+#include "cmdmain.h"

+#include <pthread.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

-#include "sleep.h"

#include "cmdparser.h"

#include "proxmark3.h"

#include "data.h"

#include "cmdparser.h"

#include "proxmark3.h"

#include "data.h"

@@ -22,17 +24,15 @@

#include "cmddata.h"

#include "cmdhw.h"

#include "cmdlf.h"

#include "cmddata.h"

#include "cmdhw.h"

#include "cmdlf.h"

-#include "cmdmain.h"

#include "util.h"

+#include "util_posix.h"

#include "cmdscript.h"

-#include "cmdcrc.h"

unsigned int current_command = CMD_UNKNOWN;

static int CmdHelp(const char *Cmd);

static int CmdQuit(const char *Cmd);

unsigned int current_command = CMD_UNKNOWN;

static int CmdHelp(const char *Cmd);

static int CmdQuit(const char *Cmd);

-static int CmdRev(const char *Cmd);

//For storing command that are received from the device

#define CMD_BUFFER_SIZE 50

//For storing command that are received from the device

#define CMD_BUFFER_SIZE 50

@@ -41,6 +41,8 @@ static UsbCommand cmdBuffer[CMD_BUFFER_SIZE];

static int cmd_head;//Starts as 0

//Points to the position of the last unread command

static int cmd_tail;//Starts as 0

static int cmd_head;//Starts as 0

//Points to the position of the last unread command

static int cmd_tail;//Starts as 0

+// to lock cmdBuffer operations from different threads

+static pthread_mutex_t cmdBufferMutex = PTHREAD_MUTEX_INITIALIZER;

static command_t CommandTable[] =

{

static command_t CommandTable[] =

{

@@ -49,7 +51,6 @@ static command_t CommandTable[] =

{"hf", CmdHF, 1, "{ High Frequency commands... }"},

{"hw", CmdHW, 1, "{ Hardware commands... }"},

{"lf", CmdLF, 1, "{ Low Frequency commands... }"},

{"hf", CmdHF, 1, "{ High Frequency commands... }"},

{"hw", CmdHW, 1, "{ Hardware commands... }"},

{"lf", CmdLF, 1, "{ Low Frequency commands... }"},

- {"reveng",CmdRev, 1, "Crc calculations from the software reveng1-30"},

{"script",CmdScript,1, "{ Scripting commands }"},

{"quit", CmdQuit, 1, "Exit program"},

{"exit", CmdQuit, 1, "Exit program"},

{"script",CmdScript,1, "{ Scripting commands }"},

{"quit", CmdQuit, 1, "Exit program"},

{"exit", CmdQuit, 1, "Exit program"},

@@ -68,14 +69,7 @@ int CmdHelp(const char *Cmd)

int CmdQuit(const char *Cmd)

{

int CmdQuit(const char *Cmd)

{

- exit(0);

- return 0;

-int CmdRev(const char *Cmd)

- CmdCrc(Cmd);

- return 0;

+ return 99;

}

/**

}

/**

@@ -87,7 +81,9 @@ int CmdRev(const char *Cmd)

void clearCommandBuffer()

{

//This is a very simple operation

void clearCommandBuffer()

{

//This is a very simple operation

+ pthread_mutex_lock(&cmdBufferMutex);

cmd_tail = cmd_head;

+ pthread_mutex_unlock(&cmdBufferMutex);

}

/**

}

/**

@@ -96,6 +92,7 @@ void clearCommandBuffer()

void storeCommand(UsbCommand *command)

{

void storeCommand(UsbCommand *command)

{

+ pthread_mutex_lock(&cmdBufferMutex);

if( ( cmd_head+1) % CMD_BUFFER_SIZE == cmd_tail)

{

//If these two are equal, we're about to overwrite in the

if( ( cmd_head+1) % CMD_BUFFER_SIZE == cmd_tail)

{

//If these two are equal, we're about to overwrite in the

@@ -107,8 +104,10 @@ void storeCommand(UsbCommand *command)

memcpy(destination, command, sizeof(UsbCommand));

cmd_head = (cmd_head +1) % CMD_BUFFER_SIZE; //increment head and wrap

memcpy(destination, command, sizeof(UsbCommand));

cmd_head = (cmd_head +1) % CMD_BUFFER_SIZE; //increment head and wrap

+ pthread_mutex_unlock(&cmdBufferMutex);

}

/**

* @brief getCommand gets a command from an internal circular buffer.

* @param response location to write command

/**

* @brief getCommand gets a command from an internal circular buffer.

* @param response location to write command

@@ -116,8 +115,10 @@ void storeCommand(UsbCommand *command)

int getCommand(UsbCommand* response)

{

int getCommand(UsbCommand* response)

{

+ pthread_mutex_lock(&cmdBufferMutex);

//If head == tail, there's nothing to read, or if we just got initialized

if(cmd_head == cmd_tail){

//If head == tail, there's nothing to read, or if we just got initialized

if(cmd_head == cmd_tail){

+ pthread_mutex_unlock(&cmdBufferMutex);

return 0;

}

//Pick out the next unread command

return 0;

}

//Pick out the next unread command

@@ -125,11 +126,11 @@ int getCommand(UsbCommand* response)

memcpy(response, last_unread, sizeof(UsbCommand));

//Increment tail - this is a circular buffer, so modulo buffer size

cmd_tail = (cmd_tail +1 ) % CMD_BUFFER_SIZE;

memcpy(response, last_unread, sizeof(UsbCommand));

//Increment tail - this is a circular buffer, so modulo buffer size

cmd_tail = (cmd_tail +1 ) % CMD_BUFFER_SIZE;

+ pthread_mutex_unlock(&cmdBufferMutex);

return 1;

}

/**

* Waits for a certain response type. This method waits for a maximum of

* ms_timeout milliseconds for a specified response command.

/**

* Waits for a certain response type. This method waits for a maximum of

* ms_timeout milliseconds for a specified response command.

@@ -139,43 +140,54 @@ int getCommand(UsbCommand* response)

* @param ms_timeout

* @return true if command was returned, otherwise false

* @param ms_timeout

* @return true if command was returned, otherwise false

-bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout) {

+bool WaitForResponseTimeoutW(uint32_t cmd, UsbCommand* response, size_t ms_timeout, bool show_warning) {

- UsbCommand resp;

+ UsbCommand resp;

- if (response == NULL)

- response = &resp;

- // Wait until the command is received

- for(size_t dm_seconds=0; dm_seconds < ms_timeout/10; dm_seconds++) {

+ if (response == NULL) {

+ response = &resp;

+ }

+ uint64_t start_time = msclock();

+ // Wait until the command is received

+ while (true) {

while(getCommand(response)) {

- if(response->cmd == cmd){

- return true;

- }

- msleep(10); // XXX ugh

- if (dm_seconds == 200) { // Two seconds elapsed

- PrintAndLog("Waiting for a response from the proxmark...");

- PrintAndLog("Don't forget to cancel its operation first by pressing on the button");

- }

+ if(response->cmd == cmd){

+ return true;

+ }

+ if (msclock() - start_time > ms_timeout) {

+ break;

+ }

+ if (msclock() - start_time > 2000 && show_warning) {

+ PrintAndLog("Waiting for a response from the proxmark...");

+ PrintAndLog("Don't forget to cancel its operation first by pressing on the button");

+ show_warning = false;

+ }

}

- return false;

+ return false;

+bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout) {

+ return WaitForResponseTimeoutW(cmd, response, ms_timeout, true);

}

bool WaitForResponse(uint32_t cmd, UsbCommand* response) {

}

bool WaitForResponse(uint32_t cmd, UsbCommand* response) {

- return WaitForResponseTimeout(cmd,response,-1);

+ return WaitForResponseTimeoutW(cmd, response, -1, true);

}

//-----------------------------------------------------------------------------

// Entry point into our code: called whenever the user types a command and

// then presses Enter, which the full command line that they typed.

//-----------------------------------------------------------------------------

// Entry point into our code: called whenever the user types a command and

// then presses Enter, which the full command line that they typed.

//-----------------------------------------------------------------------------

-void CommandReceived(char *Cmd) {

- CmdsParse(CommandTable, Cmd);

+int CommandReceived(char *Cmd) {

+ return CmdsParse(CommandTable, Cmd);

}

//-----------------------------------------------------------------------------

// Entry point into our code: called whenever we received a packet over USB

// that we weren't necessarily expecting, for example a debug print.

//-----------------------------------------------------------------------------

// Entry point into our code: called whenever we received a packet over USB

// that we weren't necessarily expecting, for example a debug print.

@@ -185,10 +197,11 @@ void UsbCommandReceived(UsbCommand *UC)

switch(UC->cmd) {

// First check if we are handling a debug message

case CMD_DEBUG_PRINT_STRING: {

switch(UC->cmd) {

// First check if we are handling a debug message

case CMD_DEBUG_PRINT_STRING: {

- char s[USB_CMD_DATA_SIZE+1] = {0x00};

+ char s[USB_CMD_DATA_SIZE+1];

+ memset(s, 0x00, sizeof(s));

size_t len = MIN(UC->arg[0],USB_CMD_DATA_SIZE);

memcpy(s,UC->d.asBytes,len);

size_t len = MIN(UC->arg[0],USB_CMD_DATA_SIZE);

memcpy(s,UC->d.asBytes,len);

- PrintAndLog("#db# %s ", s);

+ PrintAndLog("#db# %s", s);

return;

} break;

return;

} break;

@@ -199,12 +212,13 @@ void UsbCommandReceived(UsbCommand *UC)

case CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K: {

memcpy(sample_buf+(UC->arg[0]),UC->d.asBytes,UC->arg[1]);

case CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K: {

memcpy(sample_buf+(UC->arg[0]),UC->d.asBytes,UC->arg[1]);

+ return;

} break;

default:

} break;

default:

+ storeCommand(UC);

break;

}

break;

}

- storeCommand(UC);

}