Merge pull request #600 from marshmellow42/master

[proxmark3-svn] / client / comms.c

diff --git a/client/comms.c b/client/comms.c
index 5b8266fe114b3e87ce7b50599d05f75fc587b15c..97d58ef97a0abce055ac1af6a5a0fa7cfb71a305 100644 (file)
--- a/client/comms.c
+++ b/client/comms.c
@@ -21,10 +21,10 @@
 // Declare globals.
 
 // Serial port that we are communicating with the PM3 on.
-serial_port sp;
+static serial_port sp;
 
 // If TRUE, then there is no active connection to the PM3, and we will drop commands sent.
-bool offline;
+static bool offline;
 
 // Transmit buffer.
 // TODO: Use locks and execute this on the main thread, rather than the receiver
@@ -47,10 +47,52 @@ static int cmd_tail = 0;
 // to lock cmdBuffer operations from different threads
 static pthread_mutex_t cmdBufferMutex = PTHREAD_MUTEX_INITIALIZER;
 
+// These wrappers are required because it is not possible to access a static
+// global variable outside of the context of a single file.
+
+void SetOffline(bool new_offline) {
+       offline = new_offline;
+}
+
+bool IsOffline() {
+       return offline;
+}
+
+bool OpenProxmark(char *portname, bool waitCOMPort, int timeout) {
+       if (!waitCOMPort) {
+               sp = uart_open(portname);
+       } else {
+               printf("Waiting for Proxmark to appear on %s ", portname);
+               fflush(stdout);
+               int openCount = 0;
+               do {
+                       sp = uart_open(portname);
+                       msleep(1000);
+                       printf(".");
+                       fflush(stdout);
+               } while(++openCount < timeout && (sp == INVALID_SERIAL_PORT || sp == CLAIMED_SERIAL_PORT));
+               printf("\n");
+       }
+
+       // check result of uart opening
+       if (sp == INVALID_SERIAL_PORT) {
+               printf("ERROR: invalid serial port\n");
+               return false;
+       } else if (sp == CLAIMED_SERIAL_PORT) {
+               printf("ERROR: serial port is claimed by another process\n");
+               return false;
+       } else {
+               return true;
+       }
+}
+
+void CloseProxmark(void) {
+       uart_close(sp);
+}
 
 void SendCommand(UsbCommand *c) {
-       #if 0
-               printf("Sending %d bytes\n", sizeof(UsbCommand));
+       #ifdef COMMS_DEBUG
+       printf("Sending %04x cmd\n", c->cmd);
        #endif
 
        if (offline) {
@@ -63,6 +105,7 @@ void SendCommand(UsbCommand *c) {
        Not good.../holiman
        **/
        while(txcmd_pending);
+
        txcmd = *c;
        txcmd_pending = true;
 }
@@ -130,11 +173,7 @@ int getCommand(UsbCommand* response)
 }
 
 
-//-----------------------------------------------------------------------------
-// Entry point into our code: called whenever we received a packet over USB
-// that we weren't necessarily expecting, for example a debug print.
-//-----------------------------------------------------------------------------
-void UsbCommandReceived(UsbCommand *UC)
+static void UsbCommandReceived(UsbCommand *UC)
 {
        switch(UC->cmd) {
                // First check if we are handling a debug message
@@ -153,12 +192,14 @@ void UsbCommandReceived(UsbCommand *UC)
                } break;
 
                case CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K: {
+                       // FIXME: This does unsanitised copies into memory when we don't know
+                       // the size of the buffer.
                        memcpy(sample_buf+(UC->arg[0]),UC->d.asBytes,UC->arg[1]);
                        return;
                } break;
 
                default:
-                       storeCommand(UC);
+                       storeCommand(UC);
                        break;
        }
 
@@ -172,12 +213,12 @@ __attribute__((force_align_arg_pointer))
 #endif
 #endif
 *uart_receiver(void *targ) {
-       receiver_arg *arg = (receiver_arg*)targ;
+       receiver_arg *conn = (receiver_arg*)targ;
        size_t rxlen;
        uint8_t rx[sizeof(UsbCommand)];
        uint8_t *prx = rx;
 
-       while (arg->run) {
+       while (conn->run) {
                rxlen = 0;
                if (uart_receive(sp, prx, sizeof(UsbCommand) - (prx-rx), &rxlen) && rxlen) {
                        prx += rxlen;
@@ -205,15 +246,20 @@ __attribute__((force_align_arg_pointer))
  * Waits for a certain response type. This method waits for a maximum of
  * ms_timeout milliseconds for a specified response command.
  *@brief WaitForResponseTimeout
- * @param cmd command to wait for
+ * @param cmd command to wait for, or CMD_UNKNOWN to take any command.
  * @param response struct to copy received command into.
  * @param ms_timeout
+ * @param show_warning
  * @return true if command was returned, otherwise false
  */
 bool WaitForResponseTimeoutW(uint32_t cmd, UsbCommand* response, size_t ms_timeout, bool show_warning) {
 
        UsbCommand resp;
 
+       #ifdef COMMS_DEBUG
+       printf("Waiting for %04x cmd\n", cmd);
+       #endif
+
        if (response == NULL) {
                response = &resp;
        }
@@ -223,7 +269,7 @@ bool WaitForResponseTimeoutW(uint32_t cmd, UsbCommand* response, size_t ms_timeo
        // Wait until the command is received
        while (true) {
                while(getCommand(response)) {
-                       if(response->cmd == cmd){
+                       if (cmd == CMD_UNKNOWN || response->cmd == cmd) {
                                return true;
                        }
                }
@@ -233,6 +279,7 @@ bool WaitForResponseTimeoutW(uint32_t cmd, UsbCommand* response, size_t ms_timeo
                }
 
                if (msclock() - start_time > 2000 && show_warning) {
+                       // 2 seconds elapsed (but this doesn't mean the timeout was exceeded)
                        PrintAndLog("Waiting for a response from the proxmark...");
                        PrintAndLog("You can cancel this operation by pressing the pm3 button");
                        show_warning = false;