X-Git-Url: http://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/818efbebb87ec5485fbf367021dca42514dfdee0..3458bb279b00048892e56cec6f0a13e8c03f97db:/client/comms.c diff --git a/client/comms.c b/client/comms.c index 97d58ef9..c8d72b8a 100644 --- a/client/comms.c +++ b/client/comms.c @@ -9,34 +9,46 @@ // Code for communicating with the proxmark3 hardware. //----------------------------------------------------------------------------- +#include "comms.h" + +#include +#include +#include #include +#include +#include -#include "comms.h" #include "uart.h" #include "ui.h" #include "common.h" -#include "data.h" +#include "util_darwin.h" #include "util_posix.h" -// Declare globals. // Serial port that we are communicating with the PM3 on. -static serial_port sp; +static serial_port sp = NULL; +static char *serial_port_name = NULL; // If TRUE, then there is no active connection to the PM3, and we will drop commands sent. static bool offline; +typedef struct { + bool run; // If TRUE, continue running the uart_communication thread +} communication_arg_t; + +static communication_arg_t conn; +static pthread_t USB_communication_thread; + // Transmit buffer. -// TODO: Use locks and execute this on the main thread, rather than the receiver -// thread. Running on the main thread means we need to be careful in the -// 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; -volatile static bool txcmd_pending = false; +static UsbCommand txBuffer; +static bool txBuffer_pending = false; +static pthread_mutex_t txBufferMutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t txBufferSig = PTHREAD_COND_INITIALIZER; // Used by UsbReceiveCommand as a ring buffer for messages that are yet to be // processed by a command handler (WaitForResponse{,Timeout}) -static UsbCommand cmdBuffer[CMD_BUFFER_SIZE]; +#define CMD_BUFFER_SIZE 50 +static UsbCommand rxBuffer[CMD_BUFFER_SIZE]; // Points to the next empty position to write to static int cmd_head = 0; @@ -44,8 +56,9 @@ static int cmd_head = 0; // Points to the position of the last unread command static int cmd_tail = 0; -// to lock cmdBuffer operations from different threads -static pthread_mutex_t cmdBufferMutex = PTHREAD_MUTEX_INITIALIZER; +// to lock rxBuffer operations from different threads +static pthread_mutex_t rxBufferMutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t rxBufferSig = PTHREAD_COND_INITIALIZER; // These wrappers are required because it is not possible to access a static // global variable outside of the context of a single file. @@ -58,56 +71,31 @@ 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); + printf("Sending %04" PRIx64 " cmd\n", c->cmd); #endif if (offline) { PrintAndLog("Sending bytes to proxmark failed - offline"); return; - } + } + + pthread_mutex_lock(&txBufferMutex); /** - 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 + This 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); + while (txBuffer_pending) { + pthread_cond_wait(&txBufferSig, &txBufferMutex); // wait for communication thread to complete sending a previous commmand + } + + txBuffer = *c; + txBuffer_pending = true; + pthread_cond_signal(&txBufferSig); // tell communication thread that a new command can be send + + pthread_mutex_unlock(&txBufferMutex); - txcmd = *c; - txcmd_pending = true; } @@ -117,71 +105,83 @@ void SendCommand(UsbCommand *c) { * A better method could have been to have explicit command-ACKS, so we can know which ACK goes to which * operation. Right now we'll just have to live with this. */ -void clearCommandBuffer() -{ +void clearCommandBuffer() { //This is a very simple operation - pthread_mutex_lock(&cmdBufferMutex); + pthread_mutex_lock(&rxBufferMutex); cmd_tail = cmd_head; - pthread_mutex_unlock(&cmdBufferMutex); + pthread_mutex_unlock(&rxBufferMutex); } /** * @brief storeCommand stores a USB command in a circular buffer * @param UC */ -void storeCommand(UsbCommand *command) -{ - pthread_mutex_lock(&cmdBufferMutex); - if( (cmd_head+1) % CMD_BUFFER_SIZE == cmd_tail) - { +static void storeCommand(UsbCommand *command) { + pthread_mutex_lock(&rxBufferMutex); + if ((cmd_head + 1) % CMD_BUFFER_SIZE == cmd_tail) { // If these two are equal, we're about to overwrite in the // circular buffer. PrintAndLog("WARNING: Command buffer about to overwrite command! This needs to be fixed!"); } // Store the command at the 'head' location - UsbCommand* destination = &cmdBuffer[cmd_head]; + UsbCommand* destination = &rxBuffer[cmd_head]; memcpy(destination, command, sizeof(UsbCommand)); - cmd_head = (cmd_head +1) % CMD_BUFFER_SIZE; //increment head and wrap - pthread_mutex_unlock(&cmdBufferMutex); + cmd_head = (cmd_head + 1) % CMD_BUFFER_SIZE; //increment head and wrap + pthread_cond_signal(&rxBufferSig); // tell main thread that a new command can be retreived + pthread_mutex_unlock(&rxBufferMutex); } /** * @brief getCommand gets a command from an internal circular buffer. * @param response location to write command - * @return 1 if response was returned, 0 if nothing has been received + * @return 1 if response was returned, 0 if nothing has been received in time */ -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){ - pthread_mutex_unlock(&cmdBufferMutex); +static int getCommand(UsbCommand* response, uint32_t ms_timeout) { + + struct timespec end_time; + clock_gettime(CLOCK_REALTIME, &end_time); + end_time.tv_sec += ms_timeout / 1000; + end_time.tv_nsec += (ms_timeout % 1000) * 1000000; + if (end_time.tv_nsec > 1000000000) { + end_time.tv_nsec -= 1000000000; + end_time.tv_sec += 1; + } + pthread_mutex_lock(&rxBufferMutex); + int res = 0; + while (cmd_head == cmd_tail && !res) { + res = pthread_cond_timedwait(&rxBufferSig, &rxBufferMutex, &end_time); + } + if (res) { // timeout + pthread_mutex_unlock(&rxBufferMutex); return 0; } - //Pick out the next unread command - UsbCommand* last_unread = &cmdBuffer[cmd_tail]; + // Pick out the next unread command + UsbCommand* last_unread = &rxBuffer[cmd_tail]; memcpy(response, last_unread, sizeof(UsbCommand)); - //Increment tail - this is a circular buffer, so modulo buffer size + // Increment tail - this is a circular buffer, so modulo buffer size cmd_tail = (cmd_tail + 1) % CMD_BUFFER_SIZE; - pthread_mutex_unlock(&cmdBufferMutex); + pthread_mutex_unlock(&rxBufferMutex); return 1; } -static void UsbCommandReceived(UsbCommand *UC) -{ - switch(UC->cmd) { +//---------------------------------------------------------------------------------- +// Entry point into our code: called whenever we received a packet over USB. +// Handle debug commands directly, store all other commands in circular buffer. +//---------------------------------------------------------------------------------- +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); + size_t len = MIN(UC->arg[0], USB_CMD_DATA_SIZE); + memcpy(s, UC->d.asBytes,len); PrintAndLog("#db# %s", s); return; } break; @@ -191,57 +191,268 @@ static void UsbCommandReceived(UsbCommand *UC) 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; - } break; - default: - storeCommand(UC); + storeCommand(UC); break; } } -void +static bool receive_from_serial(serial_port sp, uint8_t *rx_buf, size_t len, size_t *received_len) { + size_t bytes_read = 0; + *received_len = 0; + // we eventually need to call uart_receive several times because it may timeout in the middle of a transfer + while (uart_receive(sp, rx_buf + *received_len, len - *received_len, &bytes_read) && bytes_read && *received_len < len) { + #ifdef COMMS_DEBUG + if (bytes_read != len - *received_len) { + printf("uart_receive() returned true but not enough bytes could be received. received: %zd, wanted to receive: %zd, already received before: %zd\n", + bytes_read, len - *received_len, *received_len); + } + #endif + *received_len += bytes_read; + bytes_read = 0; + } + return (*received_len == len); +} + + +static void #ifdef __has_attribute #if __has_attribute(force_align_arg_pointer) -__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; +*uart_communication(void *targ) { + communication_arg_t *conn = (communication_arg_t*)targ; uint8_t rx[sizeof(UsbCommand)]; + size_t rxlen = 0; uint8_t *prx = rx; + UsbCommand *command = (UsbCommand*)rx; + UsbResponse *response = (UsbResponse*)rx; + +#if defined(__MACH__) && defined(__APPLE__) + disableAppNap("Proxmark3 polling UART"); +#endif while (conn->run) { - rxlen = 0; - if (uart_receive(sp, prx, sizeof(UsbCommand) - (prx-rx), &rxlen) && rxlen) { + bool ACK_received = false; + prx = rx; + size_t bytes_to_read = offsetof(UsbResponse, d); // the fixed part of a new style UsbResponse. Otherwise this will be cmd and arg[0] (64 bit each) + if (receive_from_serial(sp, prx, bytes_to_read, &rxlen)) { prx += rxlen; - if (prx-rx < sizeof(UsbCommand)) { - continue; + if (response->cmd & CMD_VARIABLE_SIZE_FLAG) { // new style response with variable size +#ifdef COMMS_DEBUG + PrintAndLog("received new style response %04" PRIx16 ", datalen = %zd, arg[0] = %08" PRIx32 ", arg[1] = %08" PRIx32 ", arg[2] = %08" PRIx32, + response->cmd, response->datalen, response->arg[0], response->arg[1], response->arg[2]); +#endif + bytes_to_read = response->datalen; + if (receive_from_serial(sp, prx, bytes_to_read, &rxlen)) { + UsbCommand resp; + resp.cmd = response->cmd & ~CMD_VARIABLE_SIZE_FLAG; // remove the flag + resp.arg[0] = response->arg[0]; + resp.arg[1] = response->arg[1]; + resp.arg[2] = response->arg[2]; + memcpy(&resp.d.asBytes, &response->d.asBytes, response->datalen); + UsbCommandReceived(&resp); + if (resp.cmd == CMD_ACK) { + ACK_received = true; + } + } + } else { // old style response uses same data structure as commands. Fixed size. +#ifdef COMMS_DEBUG + PrintAndLog("received old style response %016" PRIx64 ", arg[0] = %016" PRIx64, command->cmd, command->arg[0]); +#endif + bytes_to_read = sizeof(UsbCommand) - bytes_to_read; + if (receive_from_serial(sp, prx, bytes_to_read, &rxlen)) { + UsbCommandReceived(command); + if (command->cmd == CMD_ACK) { + ACK_received = true; + } + } } - UsbCommandReceived((UsbCommand*)rx); } - prx = rx; - if(txcmd_pending) { - if (!uart_send(sp, (uint8_t*) &txcmd, sizeof(UsbCommand))) { + pthread_mutex_lock(&txBufferMutex); + // if we received an ACK the PM has done its job and waits for another command. + // We therefore can wait here as well until a new command is to be transmitted. + // The advantage is that the next command will be transmitted immediately without the need to wait for a receive timeout + if (ACK_received) { + while (!txBuffer_pending) { + pthread_cond_wait(&txBufferSig, &txBufferMutex); + } + } + if (txBuffer_pending) { + if (!uart_send(sp, (uint8_t*) &txBuffer, sizeof(UsbCommand))) { PrintAndLog("Sending bytes to proxmark failed"); } - txcmd_pending = false; + txBuffer_pending = false; } + pthread_cond_signal(&txBufferSig); // tell main thread that txBuffer is empty + pthread_mutex_unlock(&txBufferMutex); } +#if defined(__MACH__) && defined(__APPLE__) + enableAppNap(); +#endif + pthread_exit(NULL); return NULL; } +/** + * Data transfer from Proxmark to client. This method times out after + * ms_timeout milliseconds. + * @brief GetFromBigBuf + * @param dest Destination address for transfer + * @param bytes number of bytes to be transferred + * @param start_index offset into Proxmark3 BigBuf[] + * @param response struct to copy last command (CMD_ACK) into + * @param ms_timeout timeout in milliseconds + * @param show_warning display message after 2 seconds + * @return true if command was returned, otherwise false + */ +bool GetFromBigBuf(uint8_t *dest, int bytes, int start_index, UsbCommand *response, size_t ms_timeout, bool show_warning) { + + uint64_t start_time = msclock(); + uint32_t poll_time = 100; // loop every 100ms + + UsbCommand c = {CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K, {start_index, bytes, 0}}; + SendCommand(&c); + + UsbCommand resp; + if (response == NULL) { + response = &resp; + } + + int bytes_completed = 0; + while (true) { + if (msclock() - start_time > ms_timeout) { + break; // timeout + } + 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; + } + if (getCommand(response, poll_time)) { + if (response->cmd == CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) { + int copy_bytes = MIN(bytes - bytes_completed, response->arg[1]); + memcpy(dest + response->arg[0], response->d.asBytes, copy_bytes); + bytes_completed += copy_bytes; + } else if (response->cmd == CMD_ACK) { + return true; + } + } + } + + return false; +} + + +bool GetFromFpgaRAM(uint8_t *dest, int bytes) { + + uint64_t start_time = msclock(); + uint32_t poll_time = 100; // loop every 100ms + + UsbCommand c = {CMD_HF_PLOT, {0, 0, 0}}; + SendCommand(&c); + + UsbCommand response; + + int bytes_completed = 0; + bool show_warning = true; + while (true) { + if (msclock() - start_time > 2000 && show_warning) { + PrintAndLog("Waiting for a response from the proxmark..."); + PrintAndLog("You can cancel this operation by pressing the pm3 button"); + show_warning = false; + } + if (getCommand(&response, poll_time)) { + if (response.cmd == CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) { + int copy_bytes = MIN(bytes - bytes_completed, response.arg[1]); + memcpy(dest + response.arg[0], response.d.asBytes, copy_bytes); + bytes_completed += copy_bytes; + } else if (response.cmd == CMD_ACK) { + return true; + } + } + } + + return false; +} + + +bool OpenProxmark(void *port, bool wait_for_port, int timeout) { + char *portname = (char *)port; + if (!wait_for_port) { + 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"); + sp = NULL; + serial_port_name = NULL; + return false; + } else if (sp == CLAIMED_SERIAL_PORT) { + printf("ERROR: serial port is claimed by another process\n"); + sp = NULL; + serial_port_name = NULL; + return false; + } else { + // start the USB communication thread + serial_port_name = portname; + conn.run = true; + pthread_create(&USB_communication_thread, NULL, &uart_communication, &conn); + return true; + } +} + + +void CloseProxmark(void) { + conn.run = false; + +#ifdef __BIONIC__ + // In Android O and later, if an invalid pthread_t is passed to pthread_join, it calls fatal(). + // https://github.com/aosp-mirror/platform_bionic/blob/ed16b344e75f422fb36fbfd91fb30de339475880/libc/bionic/pthread_internal.cpp#L116-L128 + // + // In Bionic libc, pthread_t is an integer. + + if (USB_communication_thread != 0) { + pthread_join(USB_communication_thread, NULL); + } +#else + // pthread_t is a struct on other libc, treat as an opaque memory reference + pthread_join(USB_communication_thread, NULL); +#endif + + if (sp) { + uart_close(sp); + } + + // Clean up our state + sp = NULL; + serial_port_name = NULL; +#ifdef __BIONIC__ + memset(&USB_communication_thread, 0, sizeof(pthread_t)); +#endif +} + + /** * Waits for a certain response type. This method waits for a maximum of * ms_timeout milliseconds for a specified response command. @@ -249,7 +460,7 @@ __attribute__((force_align_arg_pointer)) * @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 + * @param show_warning display message after 2 seconds * @return true if command was returned, otherwise false */ bool WaitForResponseTimeoutW(uint32_t cmd, UsbCommand* response, size_t ms_timeout, bool show_warning) { @@ -260,30 +471,30 @@ bool WaitForResponseTimeoutW(uint32_t cmd, UsbCommand* response, size_t ms_timeo printf("Waiting for %04x cmd\n", cmd); #endif + uint64_t start_time = msclock(); + uint64_t end_time = start_time + ms_timeout; + if (response == NULL) { response = &resp; } - uint64_t start_time = msclock(); - // Wait until the command is received while (true) { - while(getCommand(response)) { - if (cmd == CMD_UNKNOWN || response->cmd == cmd) { - return true; - } - } - - if (msclock() - start_time > ms_timeout) { - break; + int32_t remaining_time = end_time - msclock(); + if (remaining_time <= 0) { + break; // timeout } - 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; } + if (getCommand(response, remaining_time)) { + if (cmd == CMD_UNKNOWN || response->cmd == cmd) { + return true; + } + } } return false; }