X-Git-Url: http://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/afdcb8c159a73aba95a017f1cfec98e8fa2b93c1..61aaee35cc838af65f943c9b6f62db28beb48c93:/client/comms.c diff --git a/client/comms.c b/client/comms.c index abbae386..2dd5534c 100644 --- a/client/comms.c +++ b/client/comms.c @@ -21,7 +21,7 @@ // Declare globals. // Serial port that we are communicating with the PM3 on. -static serial_port* port; +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; } @@ -72,10 +64,10 @@ void SendCommand(UsbCommand *c) { #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 @@ -85,6 +77,7 @@ void SendCommand(UsbCommand *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,6 +139,7 @@ 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. @@ -153,113 +147,61 @@ int getCommand(UsbCommand* response) 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 *arg = (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) { + while (arg->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; + UsbCommandReceived((UsbCommand*)rx); } - } - - // 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; - } - - bool got_command = ReceiveCommand(conn, &rx); - #ifdef COMMS_DEBUG - printf("uart_receiver: got command\n"); - #endif - pthread_mutex_unlock(&conn->recv_lock); + prx = rx; - 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 +212,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 +238,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); } +