]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/comms.c
Merge pull request #600 from marshmellow42/master
[proxmark3-svn] / client / comms.c
index abbae386021114c3083d982cc82f4efc1f010a9e..97d58ef97a0abce055ac1af6a5a0fa7cfb71a305 100644 (file)
@@ -21,7 +21,7 @@
 // Declare globals.
 
 // Serial port that we are communicating with the PM3 on.
-static serial_port* port;
+static serial_port sp;
 
 // If TRUE, then there is no active connection to the PM3, and we will drop commands sent.
 static bool offline;
@@ -32,7 +32,7 @@ static bool offline;
 // flasher, as it means SendCommand is no longer async, and can't be used as a
 // buffer for a pending command when the connection is re-established.
 static UsbCommand txcmd;
-static bool txcmd_pending;
+volatile static bool txcmd_pending = false;
 
 // Used by UsbReceiveCommand as a ring buffer for messages that are yet to be
 // processed by a command handler (WaitForResponse{,Timeout})
@@ -50,14 +50,6 @@ 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 SetSerialPort(serial_port* new_port) {
-       port = new_port;
-}
-
-serial_port* GetSerialPort() {
-       return port;
-}
-
 void SetOffline(bool new_offline) {
        offline = new_offline;
 }
@@ -66,25 +58,59 @@ 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) {
        #ifdef COMMS_DEBUG
        printf("Sending %04x cmd\n", c->cmd);
        #endif
 
        if (offline) {
-      PrintAndLog("Sending bytes to proxmark failed - offline");
-      return;
+               PrintAndLog("Sending bytes to proxmark failed - offline");
+               return;
     }
-  /**
+       /**
        The while-loop below causes hangups at times, when the pm3 unit is unresponsive
        or disconnected. The main console thread is alive, but comm thread just spins here.
        Not good.../holiman
        **/
        while(txcmd_pending);
+
        txcmd = *c;
        txcmd_pending = true;
 }
 
+
 /**
  * @brief This method should be called when sending a new command to the pm3. In case any old
  *  responses from previous commands are stored in the buffer, a call to this method should clear them.
@@ -146,120 +172,65 @@ int getCommand(UsbCommand* response)
        return 1;
 }
 
-//-----------------------------------------------------------------------------
-// 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
-       case CMD_DEBUG_PRINT_STRING: {
-               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);
-               PrintAndLog("#db# %s", s);
-               return;
-       }
-
-       case CMD_DEBUG_PRINT_INTEGERS: {
-               PrintAndLog("#db# %08x, %08x, %08x       \r\n", UC->arg[0], UC->arg[1], UC->arg[2]);
-               return;
-       }
-
-       case CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K: {
-               // FIXME: This does unsanitised copies into memory when we don't know
-               // the size of the buffer.
-               if (sample_buf) {
+               // First check if we are handling a debug message
+               case CMD_DEBUG_PRINT_STRING: {
+                       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);
+                       PrintAndLog("#db# %s", s);
+                       return;
+               } break;
+
+               case CMD_DEBUG_PRINT_INTEGERS: {
+                       PrintAndLog("#db# %08x, %08x, %08x       \r\n", UC->arg[0], UC->arg[1], UC->arg[2]);
+                       return;
+               } 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;
-       }
+                       return;
+               } break;
 
-       default: {
-               storeCommand(UC);
-               return;
-       }
+               default:
+                       storeCommand(UC);
+                       break;
        }
+
 }
 
-// Gets a single command from a proxmark3 device. This should never be used
-// with the full client.
-//
-// @param conn A receiver_arg structure.
-// @param command A buffer to store the received command.
-bool ReceiveCommand(receiver_arg* conn, UsbCommand* command) {
-       // Local recieve buffer
+
+void
+#ifdef __has_attribute
+#if __has_attribute(force_align_arg_pointer)
+__attribute__((force_align_arg_pointer)) 
+#endif
+#endif
+*uart_receiver(void *targ) {
+       receiver_arg *conn = (receiver_arg*)targ;
        size_t rxlen;
-       byte_t rx[sizeof(UsbCommand)];
-       byte_t* prx = rx;
+       uint8_t rx[sizeof(UsbCommand)];
+       uint8_t *prx = rx;
 
        while (conn->run) {
                rxlen = 0;
-               if (uart_receive(port, prx, sizeof(UsbCommand) - (prx-rx), &rxlen) && rxlen) {
+               if (uart_receive(sp, prx, sizeof(UsbCommand) - (prx-rx), &rxlen) && rxlen) {
                        prx += rxlen;
                        if (prx-rx < sizeof(UsbCommand)) {
-                               // Keep reading until we have a completed response.
                                continue;
                        }
-
-                       // We have a completed response.
-                       memcpy(command, rx, sizeof(UsbCommand));
-                       return true;
-               }
-
-               if (prx == rx) {
-                       // We got no complete command while waiting, give up control
-                       return false;
-               }
-       }
-
-       // did not get a complete command before being cancelled.
-       return false;
-}
-
-// Worker thread for processing incoming events from the PM3
-void *uart_receiver(void *targ) {
-       receiver_arg *conn = (receiver_arg*)targ;
-       UsbCommand rx;
-
-       while (conn->run) {
-               #ifdef COMMS_DEBUG
-               printf("uart_receiver: get lock\n");
-               #endif
-               // Lock up receives, in case they try to take it away from us.
-               pthread_mutex_lock(&conn->recv_lock);
-               #ifdef COMMS_DEBUG
-               printf("uart_receiver: lock acquired\n");
-               #endif
-
-               if (port == NULL) {
-                       #ifdef COMMS_DEBUG
-                       printf("uart_receiver: port disappeared\n");
-                       #endif
-                       // Our port disappeared, stall. This code path matters for the flasher,
-                       // where it is fiddling with the serial port under us.
-                       pthread_mutex_unlock(&conn->recv_lock);
-                       msleep(10);
-                       continue;
+                       UsbCommandReceived((UsbCommand*)rx);
                }
+               prx = rx;
 
-               bool got_command = ReceiveCommand(conn, &rx);
-               #ifdef COMMS_DEBUG
-               printf("uart_receiver: got command\n");
-               #endif
-               pthread_mutex_unlock(&conn->recv_lock);
-
-               if (got_command) {
-                       UsbCommandReceived(&rx);
-               }
-
-               // We aren't normally trying to transmit in the flasher when the port would
-               // be reset, so we can just keep going at this point.
-               if (txcmd_pending) {
-                       if (!uart_send(port, (byte_t*) &txcmd, sizeof(UsbCommand))) {
+               if(txcmd_pending) {
+                       if (!uart_send(sp, (uint8_t*) &txcmd, sizeof(UsbCommand))) {
                                PrintAndLog("Sending bytes to proxmark failed");
                        }
                        txcmd_pending = false;
@@ -270,23 +241,25 @@ void *uart_receiver(void *targ) {
        return NULL;
 }
 
+
 /**
  * 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, or CMD_ANY to take any command.
+ * @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(uint64_t cmd, UsbCommand* response, size_t ms_timeout, bool show_warning) {
+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;
        }
@@ -294,32 +267,33 @@ bool WaitForResponseTimeoutW(uint64_t cmd, UsbCommand* response, size_t ms_timeo
        uint64_t start_time = msclock();
 
        // Wait until the command is received
-       for (;;) {
+       while (true) {
                while(getCommand(response)) {
-                       if (cmd == CMD_ANY || response->cmd == cmd) {
+                       if (cmd == CMD_UNKNOWN || response->cmd == cmd) {
                                return true;
                        }
                }
-               
+
                if (msclock() - start_time > ms_timeout) {
-                       // We timed out.
                        break;
                }
-               
+
                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("Don't forget to cancel its operation first by pressing on the button");
-                       break;
+                       PrintAndLog("You can cancel this operation by pressing the pm3 button");
+                       show_warning = false;
                }
        }
        return false;
 }
 
-bool WaitForResponseTimeout(uint64_t cmd, UsbCommand* response, size_t ms_timeout) {
+
+bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout) {
        return WaitForResponseTimeoutW(cmd, response, ms_timeout, true);
 }
 
-bool WaitForResponse(uint64_t cmd, UsbCommand* response) {
-       return WaitForResponseTimeout(cmd, response, -1);
+bool WaitForResponse(uint32_t cmd, UsbCommand* response) {
+       return WaitForResponseTimeoutW(cmd, response, -1, true);
 }
+
Impressum, Datenschutz