}
bool lf_read(bool silent, uint32_t samples) {
- if (offline) return false;
+ if (IsOffline()) return false;
UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K, {silent,samples,0}};
clearCommandBuffer();
//And ship it to device
int CheckChipType(char cmdp) {
uint32_t wordData = 0;
- if (offline || cmdp == '1') return 0;
+ if (IsOffline() || cmdp == '1') return 0;
save_restoreGB(GRAPH_SAVE);
save_restoreDB(GRAPH_SAVE);
return 0;
}
- if (!offline && (cmdp != '1')) {
+ if (!IsOffline() && (cmdp != '1')) {
lf_read(true, 30000);
} else if (GraphTraceLen < minLength) {
PrintAndLog("Data in Graphbuffer was too small.");
// only run if graphbuffer is just noise as it should be for hitag/cotag
if (graphJustNoise(GraphBuffer, testLen)) {
// only run these tests if we are in online mode
- if (!offline && (cmdp != '1')) {
+ if (!IsOffline() && (cmdp != '1')) {
// test for em4x05 in reader talk first mode.
if (EM4x05Block0Test(&wordData)) {
PrintAndLog("\nValid EM4x05/EM4x69 Chip Found\nUse lf em 4x05readword/dump commands to read\n");
#include "cmdscript.h"
-unsigned int current_command = CMD_UNKNOWN;
-
static int CmdHelp(const char *Cmd);
static int CmdQuit(const char *Cmd);
int i = 0;
while (Commands[i].Name)
{
- if (!offline || Commands[i].Offline)
+ if (!IsOffline() || Commands[i].Offline)
PrintAndLog("%-16s %s", Commands[i].Name, Commands[i].Help);
++i;
}
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
// 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;
+}
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) {
} 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;
* 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;
}
// Wait until the command is received
while (true) {
while(getCommand(response)) {
- if(response->cmd == cmd){
+ if (cmd == CMD_UNKNOWN || response->cmd == cmd) {
return true;
}
}
}
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;
pthread_mutex_t recv_lock;
} receiver_arg;
+
+// Wrappers required as static variables can only be used in one file.
+void SetOffline(bool new_offline);
+bool IsOffline();
+
void SendCommand(UsbCommand *c);
void *uart_receiver(void *targ);
bool WaitForResponse(uint32_t cmd, UsbCommand* response);
extern serial_port sp;
-extern bool offline;
#endif // COMMS_H_
serial_port sp;
-// FIXME: what the fuckity fuck
-unsigned int current_command = CMD_UNKNOWN;
-
#define FLASH_START 0x100000
#define FLASH_SIZE (256*1024)
#define FLASH_END (FLASH_START + FLASH_SIZE)
unlink(serial_port_name);
}
-int OpenProxmark(size_t i, const char *serial_port_name) {
+bool OpenProxmark(size_t i, const char *serial_port_name) {
sp = uart_open(serial_port_name);
if (sp == INVALID_SERIAL_PORT || sp == CLAIMED_SERIAL_PORT) {
//poll once a second
- return 0;
+ return false;
}
- return 1;
+
+ return true;
}
// Turn PHDRs into flasher segments, checking for PHDR sanity and merging adjacent
SendCommand(&c);
fprintf(stderr,"Press and hold down button NOW if your bootloader requires it.\n");
}
+
msleep(100);
CloseProxmark(serial_port_name);
sleep(1);
fprintf(stderr, ".");
} while (!OpenProxmark(0, serial_port_name));
+
fprintf(stderr," Found.\n");
return 0;
void flash_free(flash_file_t *ctx);
int flash_stop_flashing(void);
void CloseProxmark(const char *serial_port_name);
-int OpenProxmark(size_t i, const char *serial_port_name);
+bool OpenProxmark(size_t i, const char *serial_port_name);
extern serial_port sp;
#endif
static unsigned int claimed_iface = 0;
unsigned char return_on_error = 0;
unsigned char error_occured = 0;
-extern unsigned int current_command;
void SendCommand(UsbCommand *c)
{
#if 0
printf("Sending %d bytes\n", sizeof(UsbCommand));
#endif
- current_command = c->cmd;
ret = usb_bulk_write(devh, 0x01, (char*)c, sizeof(UsbCommand), 1000);
if (ret<0) {
error_occured = 1;
pthread_t reader_thread;
bool execCommand = (script_cmd != NULL);
bool stdinOnPipe = !isatty(STDIN_FILENO);
-
+
memset(&conn, 0, sizeof(receiver_arg));
if (usb_present) {
conn.run = true;
+ SetOffline(false);
pthread_create(&reader_thread, NULL, &uart_receiver, &conn);
// cache Version information now:
CmdVersion(NULL);
+ } else {
+ SetOffline(true);
}
// file with script
read_history(".history");
- while (1) {
+ while (1) {
// If there is a script file
if (script_file)
{
if(strcmp(argv[i],"-f") == 0 || strcmp(argv[i],"-flush") == 0){
printf("Output will be flushed after every print.\n");
- flushAfterWrite = 1;
+ SetFlushAfterWrite(true);
}
if(strcmp(argv[i],"-w") == 0 || strcmp(argv[i],"-wait") == 0){
if (sp == INVALID_SERIAL_PORT) {
printf("ERROR: invalid serial port\n");
usb_present = false;
- offline = 1;
} else if (sp == CLAIMED_SERIAL_PORT) {
printf("ERROR: serial port is claimed by another process\n");
usb_present = false;
- offline = 1;
} else {
usb_present = true;
- offline = 0;
}
#ifdef HAVE_GUI
double CursorScaleFactor = 1;
int PlotGridX=0, PlotGridY=0, PlotGridXdefault= 64, PlotGridYdefault= 64, CursorCPos= 0, CursorDPos= 0;
-int offline;
-int flushAfterWrite = 0; //buzzy
+bool flushAfterWrite = false; //buzzy
int GridOffset = 0;
bool GridLocked = false;
bool showDemod = true;
}
va_end(argptr2);
- if (flushAfterWrite == 1) //buzzy
+ if (flushAfterWrite) //buzzy
{
fflush(NULL);
}
{
logfilename = fn;
}
+
+void SetFlushAfterWrite(bool flush_after_write) {
+ flushAfterWrite = flush_after_write;
+}
+
void RepaintGraphWindow(void);
void PrintAndLog(char *fmt, ...);
void SetLogFilename(char *fn);
+void SetFlushAfterWrite(bool flush_after_write);
extern double CursorScaleFactor;
extern int PlotGridX, PlotGridY, PlotGridXdefault, PlotGridYdefault, CursorCPos, CursorDPos, GridOffset;
-extern int flushAfterWrite; //buzzy
extern bool GridLocked;
extern bool showDemod;
OBJDIR = obj
-INCLUDE = -I../include -I../common
+INCLUDE = -I../include -I../common -I.
TAR=tar
TARFLAGS = -C .. -rvf
#include <stdint.h>
#include <stdlib.h>
//#include "iso15693tools.h"
+#ifdef ON_DEVICE
+#include "printf.h"
+#else
+#include <stdio.h>
+#endif
+
#define POLY 0x8408
}
-int sprintf(char *str, const char *format, ...);
-
// returns a string representation of the UID
// UID is transmitted and stored LSB first, displayed MSB first
// target char* buffer, where to put the UID, if NULL a static buffer is returned
projects / proxmark3-svn / commitdiff