[proxmark3-svn] / client / comms.c

//-----------------------------------------------------------------------------
// Copyright (C) 2009 Michael Gernoth <michael at gernoth.net>
// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
//
// This code is licensed to you under the terms of the GNU GPL, version 2 or,
// at your option, any later version. See the LICENSE.txt file for the text of
// the license.
//-----------------------------------------------------------------------------
// Code for communicating with the proxmark3 hardware.
//-----------------------------------------------------------------------------

#include "comms.h"

#include <pthread.h>
#if defined(__linux__) && !defined(NO_UNLINK)
#include <unistd.h>		// for unlink()
#endif
#include "uart.h"
#include "ui.h"
#include "common.h"
#include "util_darwin.h"
#include "util_posix.h"


// Serial port that we are communicating with the PM3 on.
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
	bool block_after_ACK; // if true, block after receiving an ACK package
} communication_arg_t;

static communication_arg_t conn;
static pthread_t USB_communication_thread;

// Transmit buffer.
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 rxBuffer[CMD_BUFFER_SIZE];

// Points to the next empty position to write to
static int cmd_head = 0;

// Points to the position of the last unread command
static int cmd_tail = 0;

// to lock rxBuffer operations from different threads
static pthread_mutex_t rxBufferMutex = 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;
}

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;
    }

	pthread_mutex_lock(&txBufferMutex);
	/**
	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 (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);

}


/**
 * @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.
 *  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()
{
	//This is a very simple operation
	pthread_mutex_lock(&rxBufferMutex);
	cmd_tail = cmd_head;
	pthread_mutex_unlock(&rxBufferMutex);
}

/**
 * @brief storeCommand stores a USB command in a circular buffer
 * @param UC
 */
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 = &rxBuffer[cmd_head];
	memcpy(destination, command, sizeof(UsbCommand));

	cmd_head = (cmd_head +1) % CMD_BUFFER_SIZE; //increment head and wrap
	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
 */
static int getCommand(UsbCommand* response)
{
	pthread_mutex_lock(&rxBufferMutex);
	//If head == tail, there's nothing to read, or if we just got initialized
	if (cmd_head == cmd_tail){
		pthread_mutex_unlock(&rxBufferMutex);
		return 0;
	}

	//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
	cmd_tail = (cmd_tail + 1) % CMD_BUFFER_SIZE;

	pthread_mutex_unlock(&rxBufferMutex);
	return 1;
}


//----------------------------------------------------------------------------------
// 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);
			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;

		default:
 			storeCommand(UC);
			break;
	}

}


static void
#ifdef __has_attribute
#if __has_attribute(force_align_arg_pointer)
__attribute__((force_align_arg_pointer)) 
#endif
#endif
*uart_communication(void *targ) {
	communication_arg_t *conn = (communication_arg_t*)targ;
	size_t rxlen;
	UsbCommand rx;
	UsbCommand *prx = &rx;

#if defined(__MACH__) && defined(__APPLE__)
	disableAppNap("Proxmark3 polling UART");
#endif

	while (conn->run) {
		rxlen = 0;
		bool ACK_received = false;
		if (uart_receive(sp, (uint8_t *)prx, sizeof(UsbCommand) - (prx-&rx), &rxlen) && rxlen) {
			prx += rxlen;
			if (prx-&rx < sizeof(UsbCommand)) {
				continue;
			}
			UsbCommandReceived(&rx);
			if (rx.cmd == CMD_ACK) {
				ACK_received = true;
			}
		}
		prx = &rx;

		
		pthread_mutex_lock(&txBufferMutex);

		if (conn->block_after_ACK) {
			// if we just received an ACK, wait here until a new command is to be transmitted
			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");
			}
			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)
{
	UsbCommand c = {CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K, {start_index, bytes, 0}};
	SendCommand(&c);

	uint64_t start_time = msclock();

	UsbCommand resp;
  	if (response == NULL) {
		response = &resp;
	}

	int bytes_completed = 0;
	while(true) {
		if (getCommand(response)) {
			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;
			}
		}

		if (msclock() - start_time > ms_timeout) {
			break;
		}

		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;
		}
	}

	return false;
}

	
bool OpenProxmark(void *port, bool wait_for_port, int timeout, bool flash_mode) {
	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;
		conn.block_after_ACK = flash_mode;
		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);
	}

#if defined(__linux__) && !defined(NO_UNLINK)
	// Fix for linux, it seems that it is extremely slow to release the serial port file descriptor /dev/*
	//
	// This may be disabled at compile-time with -DNO_UNLINK (used for a JNI-based serial port on Android).
	if (serial_port_name) {
		unlink(serial_port_name);
	}
#endif

	// 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.
 *@brief WaitForResponseTimeout
 * @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 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) {

	UsbCommand resp;

	#ifdef COMMS_DEBUG
	printf("Waiting for %04x cmd\n", cmd);
	#endif

	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;
		}

		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;
		}
	}
	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) {
	return WaitForResponseTimeoutW(cmd, response, -1, true);
}
Commit	Line	Data
f5ecd97b	1	//-----------------------------------------------------------------------------
	2	// Copyright (C) 2009 Michael Gernoth <michael at gernoth.net>
	3	// Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
	4	//
	5	// This code is licensed to you under the terms of the GNU GPL, version 2 or,
	6	// at your option, any later version. See the LICENSE.txt file for the text of
	7	// the license.
	8	//-----------------------------------------------------------------------------
	9	// Code for communicating with the proxmark3 hardware.
	10	//-----------------------------------------------------------------------------
	11
f5ecd97b	12	#include "comms.h"
ad939de5	13
ad939de5	14	#include <pthread.h>
577b1c27	15	#if defined(__linux__) && !defined(NO_UNLINK)
ad939de5	16	#include <unistd.h> // for unlink()
ad939de5	17	#endif
f5ecd97b	18	#include "uart.h"
	19	#include "ui.h"
	20	#include "common.h"
2a537311	21	#include "util_darwin.h"
f5ecd97b	22	#include "util_posix.h"
f5ecd97b	23
f5ecd97b	24
f5ecd97b	25	// Serial port that we are communicating with the PM3 on.
ad939de5	26	static serial_port sp = NULL;
ad939de5	27	static char *serial_port_name = NULL;
f5ecd97b	28
f5ecd97b	29	// If TRUE, then there is no active connection to the PM3, and we will drop commands sent.
61aaee35	30	static bool offline;
f5ecd97b	31
ad939de5	32	typedef struct {
	33	bool run; // If TRUE, continue running the uart_communication thread
	34	bool block_after_ACK; // if true, block after receiving an ACK package
	35	} communication_arg_t;
	36
	37	static communication_arg_t conn;
	38	static pthread_t USB_communication_thread;
	39
f5ecd97b	40	// Transmit buffer.
ad939de5	41	static UsbCommand txBuffer;
	42	static bool txBuffer_pending = false;
	43	static pthread_mutex_t txBufferMutex = PTHREAD_MUTEX_INITIALIZER;
	44	static pthread_cond_t txBufferSig = PTHREAD_COND_INITIALIZER;
f5ecd97b	45
	46	// Used by UsbReceiveCommand as a ring buffer for messages that are yet to be
	47	// processed by a command handler (WaitForResponse{,Timeout})
ad939de5	48	static UsbCommand rxBuffer[CMD_BUFFER_SIZE];
f5ecd97b	49
	50	// Points to the next empty position to write to
	51	static int cmd_head = 0;
	52
	53	// Points to the position of the last unread command
	54	static int cmd_tail = 0;
	55
ad939de5	56	// to lock rxBuffer operations from different threads
ad939de5	57	static pthread_mutex_t rxBufferMutex = PTHREAD_MUTEX_INITIALIZER;
f5ecd97b	58
61aaee35	59	// These wrappers are required because it is not possible to access a static
	60	// global variable outside of the context of a single file.
	61
	62	void SetOffline(bool new_offline) {
	63	offline = new_offline;
	64	}
	65
	66	bool IsOffline() {
	67	return offline;
	68	}
f5ecd97b	69
f5ecd97b	70	void SendCommand(UsbCommand *c) {
61aaee35	71	#ifdef COMMS_DEBUG
61aaee35	72	printf("Sending %04x cmd\n", c->cmd);
f5ecd97b	73	#endif
	74
	75	if (offline) {
	76	PrintAndLog("Sending bytes to proxmark failed - offline");
	77	return;
	78	}
ad939de5	79
ad939de5	80	pthread_mutex_lock(&txBufferMutex);
f5ecd97b	81	/**
ad939de5	82	This causes hangups at times, when the pm3 unit is unresponsive or disconnected. The main console thread is alive,
ad939de5	83	but comm thread just spins here. Not good.../holiman
f5ecd97b	84	**/
ad939de5	85	while (txBuffer_pending) {
	86	pthread_cond_wait(&txBufferSig, &txBufferMutex); // wait for communication thread to complete sending a previous commmand
	87	}
	88
	89	txBuffer = *c;
	90	txBuffer_pending = true;
	91	pthread_cond_signal(&txBufferSig); // tell communication thread that a new command can be send
	92
	93	pthread_mutex_unlock(&txBufferMutex);
818efbeb	94
f5ecd97b	95	}
	96
	97
	98	/**
	99	* @brief This method should be called when sending a new command to the pm3. In case any old
	100	* responses from previous commands are stored in the buffer, a call to this method should clear them.
	101	* A better method could have been to have explicit command-ACKS, so we can know which ACK goes to which
	102	* operation. Right now we'll just have to live with this.
	103	*/
	104	void clearCommandBuffer()
	105	{
	106	//This is a very simple operation
ad939de5	107	pthread_mutex_lock(&rxBufferMutex);
f5ecd97b	108	cmd_tail = cmd_head;
ad939de5	109	pthread_mutex_unlock(&rxBufferMutex);
f5ecd97b	110	}
	111
	112	/**
	113	* @brief storeCommand stores a USB command in a circular buffer
	114	* @param UC
	115	*/
ad939de5	116	static void storeCommand(UsbCommand *command)
f5ecd97b	117	{
ad939de5	118	pthread_mutex_lock(&rxBufferMutex);
f5ecd97b	119	if( (cmd_head+1) % CMD_BUFFER_SIZE == cmd_tail)
	120	{
	121	// If these two are equal, we're about to overwrite in the
	122	// circular buffer.
	123	PrintAndLog("WARNING: Command buffer about to overwrite command! This needs to be fixed!");
	124	}
	125
	126	// Store the command at the 'head' location
ad939de5	127	UsbCommand* destination = &rxBuffer[cmd_head];
f5ecd97b	128	memcpy(destination, command, sizeof(UsbCommand));
	129
	130	cmd_head = (cmd_head +1) % CMD_BUFFER_SIZE; //increment head and wrap
ad939de5	131	pthread_mutex_unlock(&rxBufferMutex);
f5ecd97b	132	}
	133
	134
	135	/**
	136	* @brief getCommand gets a command from an internal circular buffer.
	137	* @param response location to write command
	138	* @return 1 if response was returned, 0 if nothing has been received
	139	*/
ad939de5	140	static int getCommand(UsbCommand* response)
f5ecd97b	141	{
ad939de5	142	pthread_mutex_lock(&rxBufferMutex);
f5ecd97b	143	//If head == tail, there's nothing to read, or if we just got initialized
f5ecd97b	144	if (cmd_head == cmd_tail){
ad939de5	145	pthread_mutex_unlock(&rxBufferMutex);
f5ecd97b	146	return 0;
	147	}
	148
	149	//Pick out the next unread command
ad939de5	150	UsbCommand* last_unread = &rxBuffer[cmd_tail];
f5ecd97b	151	memcpy(response, last_unread, sizeof(UsbCommand));
	152	//Increment tail - this is a circular buffer, so modulo buffer size
	153	cmd_tail = (cmd_tail + 1) % CMD_BUFFER_SIZE;
	154
ad939de5	155	pthread_mutex_unlock(&rxBufferMutex);
f5ecd97b	156	return 1;
	157	}
	158
	159
babca445	160	//----------------------------------------------------------------------------------
	161	// Entry point into our code: called whenever we received a packet over USB.
	162	// Handle debug commands directly, store all other commands in circular buffer.
	163	//----------------------------------------------------------------------------------
818efbeb	164	static void UsbCommandReceived(UsbCommand *UC)
f5ecd97b	165	{
	166	switch(UC->cmd) {
	167	// First check if we are handling a debug message
	168	case CMD_DEBUG_PRINT_STRING: {
	169	char s[USB_CMD_DATA_SIZE+1];
	170	memset(s, 0x00, sizeof(s));
	171	size_t len = MIN(UC->arg[0],USB_CMD_DATA_SIZE);
	172	memcpy(s,UC->d.asBytes,len);
	173	PrintAndLog("#db# %s", s);
	174	return;
	175	} break;
	176
	177	case CMD_DEBUG_PRINT_INTEGERS: {
	178	PrintAndLog("#db# %08x, %08x, %08x \r\n", UC->arg[0], UC->arg[1], UC->arg[2]);
	179	return;
	180	} break;
	181
f5ecd97b	182	default:
818efbeb	183	storeCommand(UC);
f5ecd97b	184	break;
	185	}
	186
	187	}
	188
	189
ad939de5	190	static void
f5ecd97b	191	#ifdef __has_attribute
	192	#if __has_attribute(force_align_arg_pointer)
	193	__attribute__((force_align_arg_pointer))
	194	#endif
	195	#endif
ad939de5	196	uart_communication(void targ) {
ad939de5	197	communication_arg_t conn = (communication_arg_t)targ;
f5ecd97b	198	size_t rxlen;
ad939de5	199	UsbCommand rx;
ad939de5	200	UsbCommand *prx = &rx;
f5ecd97b	201
2a537311 A	202	#if defined(__MACH__) && defined(__APPLE__)
	203	disableAppNap("Proxmark3 polling UART");
	204	#endif
	205
818efbeb	206	while (conn->run) {
f5ecd97b	207	rxlen = 0;
ad939de5	208	bool ACK_received = false;
ad939de5	209	if (uart_receive(sp, (uint8_t *)prx, sizeof(UsbCommand) - (prx-&rx), &rxlen) && rxlen) {
f5ecd97b	210	prx += rxlen;
ad939de5	211	if (prx-&rx < sizeof(UsbCommand)) {
f5ecd97b	212	continue;
f5ecd97b	213	}
ad939de5	214	UsbCommandReceived(&rx);
	215	if (rx.cmd == CMD_ACK) {
	216	ACK_received = true;
	217	}
f5ecd97b	218	}
ad939de5	219	prx = &rx;
	220
	221
	222	pthread_mutex_lock(&txBufferMutex);
f5ecd97b	223
ad939de5	224	if (conn->block_after_ACK) {
	225	// if we just received an ACK, wait here until a new command is to be transmitted
	226	if (ACK_received) {
	227	while (!txBuffer_pending) {
	228	pthread_cond_wait(&txBufferSig, &txBufferMutex);
	229	}
	230	}
	231	}
	232
	233	if(txBuffer_pending) {
	234	if (!uart_send(sp, (uint8_t*) &txBuffer, sizeof(UsbCommand))) {
f5ecd97b	235	PrintAndLog("Sending bytes to proxmark failed");
f5ecd97b	236	}
ad939de5	237	txBuffer_pending = false;
ad939de5	238	pthread_cond_signal(&txBufferSig); // tell main thread that txBuffer is empty
f5ecd97b	239	}
ad939de5	240
ad939de5	241	pthread_mutex_unlock(&txBufferMutex);
f5ecd97b	242	}
f5ecd97b	243
2a537311 A	244	#if defined(__MACH__) && defined(__APPLE__)
	245	enableAppNap();
	246	#endif
	247
f5ecd97b	248	pthread_exit(NULL);
	249	return NULL;
	250	}
	251
	252
babca445	253	/**
	254	* Data transfer from Proxmark to client. This method times out after
	255	* ms_timeout milliseconds.
	256	* @brief GetFromBigBuf
	257	* @param dest Destination address for transfer
	258	* @param bytes number of bytes to be transferred
	259	* @param start_index offset into Proxmark3 BigBuf[]
	260	* @param response struct to copy last command (CMD_ACK) into
	261	* @param ms_timeout timeout in milliseconds
	262	* @param show_warning display message after 2 seconds
	263	* @return true if command was returned, otherwise false
	264	*/
	265	bool GetFromBigBuf(uint8_t dest, int bytes, int start_index, UsbCommand response, size_t ms_timeout, bool show_warning)
	266	{
	267	UsbCommand c = {CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K, {start_index, bytes, 0}};
	268	SendCommand(&c);
	269
	270	uint64_t start_time = msclock();
	271
	272	UsbCommand resp;
	273	if (response == NULL) {
	274	response = &resp;
	275	}
	276
	277	int bytes_completed = 0;
	278	while(true) {
	279	if (getCommand(response)) {
	280	if (response->cmd == CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {
	281	int copy_bytes = MIN(bytes - bytes_completed, response->arg[1]);
	282	memcpy(dest + response->arg[0], response->d.asBytes, copy_bytes);
	283	bytes_completed += copy_bytes;
	284	} else if (response->cmd == CMD_ACK) {
	285	return true;
	286	}
	287	}
	288
	289	if (msclock() - start_time > ms_timeout) {
	290	break;
	291	}
	292
	293	if (msclock() - start_time > 2000 && show_warning) {
	294	PrintAndLog("Waiting for a response from the proxmark...");
	295	PrintAndLog("You can cancel this operation by pressing the pm3 button");
	296	show_warning = false;
	297	}
	298	}
	299
	300	return false;
	301	}
	302
ad939de5	303
	304	bool OpenProxmark(void *port, bool wait_for_port, int timeout, bool flash_mode) {
	305	char portname = (char )port;
	306	if (!wait_for_port) {
	307	sp = uart_open(portname);
	308	} else {
	309	printf("Waiting for Proxmark to appear on %s ", portname);
	310	fflush(stdout);
	311	int openCount = 0;
	312	do {
	313	sp = uart_open(portname);
	314	msleep(1000);
	315	printf(".");
	316	fflush(stdout);
	317	} while(++openCount < timeout && (sp == INVALID_SERIAL_PORT \|\| sp == CLAIMED_SERIAL_PORT));
	318	printf("\n");
	319	}
	320
	321	// check result of uart opening
	322	if (sp == INVALID_SERIAL_PORT) {
	323	printf("ERROR: invalid serial port\n");
	324	sp = NULL;
	325	serial_port_name = NULL;
	326	return false;
	327	} else if (sp == CLAIMED_SERIAL_PORT) {
	328	printf("ERROR: serial port is claimed by another process\n");
	329	sp = NULL;
	330	serial_port_name = NULL;
	331	return false;
	332	} else {
	333	// start the USB communication thread
	334	serial_port_name = portname;
	335	conn.run = true;
	336	conn.block_after_ACK = flash_mode;
	337	pthread_create(&USB_communication_thread, NULL, &uart_communication, &conn);
	338	return true;
	339	}
	340	}
	341
	342
	343	void CloseProxmark(void) {
	344	conn.run = false;
7b2cd970 MF	345
	346	#ifdef __BIONIC__
	347	// In Android O and later, if an invalid pthread_t is passed to pthread_join, it calls fatal().
	348	// https://github.com/aosp-mirror/platform_bionic/blob/ed16b344e75f422fb36fbfd91fb30de339475880/libc/bionic/pthread_internal.cpp#L116-L128
	349	//
	350	// In Bionic libc, pthread_t is an integer.
	351
	352	if (USB_communication_thread != 0) {
	353	pthread_join(USB_communication_thread, NULL);
	354	}
	355	#else
	356	// pthread_t is a struct on other libc, treat as an opaque memory reference
ad939de5	357	pthread_join(USB_communication_thread, NULL);
7b2cd970	358	#endif
2bb7f7e3 MF	359
	360	if (sp) {
	361	uart_close(sp);
	362	}
	363
577b1c27	364	#if defined(__linux__) && !defined(NO_UNLINK)
ad939de5	365	// Fix for linux, it seems that it is extremely slow to release the serial port file descriptor /dev/*
577b1c27 MF	366	//
577b1c27 MF	367	// This may be disabled at compile-time with -DNO_UNLINK (used for a JNI-based serial port on Android).
ad939de5	368	if (serial_port_name) {
	369	unlink(serial_port_name);
	370	}
	371	#endif
2bb7f7e3 MF	372
	373	// Clean up our state
	374	sp = NULL;
	375	serial_port_name = NULL;
eed83b91	376	#ifdef __BIONIC__
7b2cd970	377	memset(&USB_communication_thread, 0, sizeof(pthread_t));
eed83b91	378	#endif
ad939de5	379	}
ad939de5	380
babca445	381
f5ecd97b	382	/**
	383	* Waits for a certain response type. This method waits for a maximum of
	384	* ms_timeout milliseconds for a specified response command.
	385	*@brief WaitForResponseTimeout
61aaee35	386	* @param cmd command to wait for, or CMD_UNKNOWN to take any command.
f5ecd97b	387	* @param response struct to copy received command into.
f5ecd97b	388	* @param ms_timeout
babca445	389	* @param show_warning display message after 2 seconds
f5ecd97b	390	* @return true if command was returned, otherwise false
	391	*/
	392	bool WaitForResponseTimeoutW(uint32_t cmd, UsbCommand* response, size_t ms_timeout, bool show_warning) {
	393
	394	UsbCommand resp;
	395
61aaee35	396	#ifdef COMMS_DEBUG
	397	printf("Waiting for %04x cmd\n", cmd);
	398	#endif
	399
f5ecd97b	400	if (response == NULL) {
	401	response = &resp;
	402	}
	403
	404	uint64_t start_time = msclock();
	405
	406	// Wait until the command is received
	407	while (true) {
	408	while(getCommand(response)) {
61aaee35	409	if (cmd == CMD_UNKNOWN \|\| response->cmd == cmd) {
f5ecd97b	410	return true;
	411	}
	412	}
	413
	414	if (msclock() - start_time > ms_timeout) {
	415	break;
	416	}
	417
	418	if (msclock() - start_time > 2000 && show_warning) {
61aaee35	419	// 2 seconds elapsed (but this doesn't mean the timeout was exceeded)
f5ecd97b	420	PrintAndLog("Waiting for a response from the proxmark...");
	421	PrintAndLog("You can cancel this operation by pressing the pm3 button");
	422	show_warning = false;
	423	}
	424	}
	425	return false;
	426	}
	427
	428
	429	bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout) {
	430	return WaitForResponseTimeoutW(cmd, response, ms_timeout, true);
	431	}
	432
	433	bool WaitForResponse(uint32_t cmd, UsbCommand* response) {
	434	return WaitForResponseTimeoutW(cmd, response, -1, true);
	435	}
	436