cvs.zerfleddert.de Git - proxmark3-svn/blob - client/proxmark3.c

   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 // Main binary
  10 //-----------------------------------------------------------------------------
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <pthread.h>
  16 #include <unistd.h>
  17 #include <readline/readline.h>
  18 #include <readline/history.h>
  19 //#include "proxusb.h"
  20 #include "proxmark3.h"
  21 #include "proxgui.h"
  22 #include "cmdmain.h"
  23 #include "uart.h"
  24 #include "ui.h"
  25 #include "sleep.h"
  26 #include "cmdparser.h"
  27 #include "cmdmain.h"
  28
  29 // a global mutex to prevent interlaced printing from different threads
  30 pthread_mutex_t print_lock;
  31
  32 static serial_port sp;
  33 static UsbCommand txcmd;
  34 volatile static bool txcmd_pending = false;
  35
  36 void SendCommand(UsbCommand *c) {
  37         #if 0
  38                 printf("Sending %d bytes\n", sizeof(UsbCommand));
  39         #endif
  40
  41         if (offline) {
  42       PrintAndLog("Sending bytes to proxmark failed - offline");
  43       return;
  44     }
  45   /**
  46         The while-loop below causes hangups at times, when the pm3 unit is unresponsive
  47         or disconnected. The main console thread is alive, but comm thread just spins here.
  48         Not good.../holiman
  49         **/
  50         while(txcmd_pending);
  51         txcmd = *c;
  52         txcmd_pending = true;
  53 }
  54
  55 struct receiver_arg {
  56         int run;
  57 };
  58
  59 struct main_loop_arg {
  60         int usb_present;
  61         char *script_cmds_file;
  62 };
  63
  64 byte_t rx[0x1000000];
  65 byte_t* prx = rx;
  66
  67 static void *uart_receiver(void *targ) {
  68         struct receiver_arg *arg = (struct receiver_arg*)targ;
  69         size_t rxlen;
  70         size_t cmd_count;
  71
  72         while (arg->run) {
  73                 rxlen = sizeof(UsbCommand);
  74                 if (uart_receive(sp, prx, &rxlen)) {
  75                         prx += rxlen;
  76                         if (((prx-rx) % sizeof(UsbCommand)) != 0) {
  77                                 continue;
  78                         }
  79                         cmd_count = (prx-rx) / sizeof(UsbCommand);
  80
  81                         for (size_t i = 0; i < cmd_count; i++) {
  82                                 UsbCommandReceived((UsbCommand*)(rx+(i*sizeof(UsbCommand))));
  83                         }
  84                 }
  85                 prx = rx;
  86
  87                 if(txcmd_pending) {
  88                         if (!uart_send(sp, (byte_t*) &txcmd, sizeof(UsbCommand))) {
  89                                 PrintAndLog("Sending bytes to proxmark failed");
  90                         }
  91                         txcmd_pending = false;
  92                 }
  93         }
  94
  95         pthread_exit(NULL);
  96         return NULL;
  97 }
  98
  99 static void *main_loop(void *targ) {
 100         struct main_loop_arg *arg = (struct main_loop_arg*)targ;
 101         struct receiver_arg rarg;
 102         char *cmd = NULL;
 103         pthread_t reader_thread;
 104
 105         if (arg->usb_present == 1) {
 106                 rarg.run = 1;
 107                 pthread_create(&reader_thread, NULL, &uart_receiver, &rarg);
 108         }
 109
 110         FILE *script_file = NULL;
 111         char script_cmd_buf[256];  // iceman, needs lua script the same file_path_buffer as the rest
 112
 113         if (arg->script_cmds_file) {
 114                 script_file = fopen(arg->script_cmds_file, "r");
 115                 if (script_file) {
 116                         printf("using 'scripting' commands file %s\n", arg->script_cmds_file);
 117                 }
 118         }
 119
 120         read_history(".history");
 121
 122         while(1)  {
 123
 124                 // If there is a script file
 125                 if (script_file)
 126                 {
 127                         if (!fgets(script_cmd_buf, sizeof(script_cmd_buf), script_file)) {
 128                                 fclose(script_file);
 129                                 script_file = NULL;
 130                         } else {
 131                                 char *nl;
 132                                 nl = strrchr(script_cmd_buf, '\r');
 133                                 if (nl) *nl = '\0';
 134
 135                                 nl = strrchr(script_cmd_buf, '\n');
 136                                 if (nl) *nl = '\0';
 137
 138                                 if ((cmd = (char*) malloc(strlen(script_cmd_buf) + 1)) != NULL) {
 139                                         memset(cmd, 0, strlen(script_cmd_buf));
 140                                         strcpy(cmd, script_cmd_buf);
 141                                         printf("%s\n", cmd);
 142                                 }
 143                         }
 144                 }
 145
 146                 if (!script_file) {
 147                         cmd = readline(PROXPROMPT);
 148                 }
 149
 150                 if (cmd) {
 151
 152                         while(cmd[strlen(cmd) - 1] == ' ')
 153                                 cmd[strlen(cmd) - 1] = 0x00;
 154
 155                         if (cmd[0] != 0x00) {
 156                                 if (strncmp(cmd, "quit", 4) == 0) {
 157                                         exit(0);
 158                                         break;
 159                                 }
 160                                 CommandReceived(cmd);
 161                                 add_history(cmd);
 162                         }
 163                         free(cmd);
 164                 } else {
 165                         printf("\n");
 166                         break;
 167                 }
 168         }
 169
 170         write_history(".history");
 171
 172         if (arg->usb_present == 1) {
 173                 rarg.run = 0;
 174                 pthread_join(reader_thread, NULL);
 175         }
 176
 177         if (script_file) {
 178                 fclose(script_file);
 179                 script_file = NULL;
 180         }
 181
 182         ExitGraphics();
 183         pthread_exit(NULL);
 184         return NULL;
 185 }
 186
 187 static void dumpAllHelp(int markdown)
 188 {
 189   printf("\n%sProxmark3 command dump%s\n\n",markdown?"# ":"",markdown?"":"\n======================");
 190   printf("Some commands are available only if a Proxmark is actually connected.%s\n",markdown?"  ":"");
 191   printf("Check column \"offline\" for their availability.\n");
 192   printf("\n");
 193   command_t *cmds = getTopLevelCommandTable();
 194   dumpCommandsRecursive(cmds, markdown);
 195 }
 196
 197 int main(int argc, char* argv[]) {
 198         srand(time(0));
 199
 200         if (argc < 2) {
 201                 printf("syntax: %s <port>\n\n",argv[0]);
 202                 printf("\tLinux example:'%s /dev/ttyACM0'\n\n", argv[0]);
 203                 printf("help:   %s -h\n\n", argv[0]);
 204                 printf("\tDump all interactive help at once\n");
 205                 printf("markdown:   %s -m\n\n", argv[0]);
 206                 printf("\tDump all interactive help at once in markdown syntax\n");
 207                 return 1;
 208         }
 209         if (strcmp(argv[1], "-h") == 0) {
 210                 printf("syntax: %s <port>\n\n",argv[0]);
 211                 printf("\tLinux example:'%s /dev/ttyACM0'\n\n", argv[0]);
 212                 dumpAllHelp(0);
 213                 return 0;
 214         }
 215         if (strcmp(argv[1], "-m") == 0) {
 216                 dumpAllHelp(1);
 217                 return 0;
 218         }
 219         // Make sure to initialize
 220         struct main_loop_arg marg = {
 221                 .usb_present = 0,
 222                 .script_cmds_file = NULL
 223         };
 224         pthread_t main_loop_t;
 225
 226
 227         sp = uart_open(argv[1]);
 228         if (sp == INVALID_SERIAL_PORT) {
 229                 printf("ERROR: invalid serial port\n");
 230                 marg.usb_present = 0;
 231                 offline = 1;
 232         } else if (sp == CLAIMED_SERIAL_PORT) {
 233                 printf("ERROR: serial port is claimed by another process\n");
 234                 marg.usb_present = 0;
 235                 offline = 1;
 236         } else {
 237                 marg.usb_present = 1;
 238                 offline = 0;
 239         }
 240
 241         // If the user passed the filename of the 'script' to execute, get it
 242         if (argc > 2 && argv[2]) {
 243                 if (argv[2][0] == 'f' &&  //buzzy, if a word 'flush' passed, flush the output after every log entry.
 244                         argv[2][1] == 'l' &&
 245                         argv[2][2] == 'u' &&
 246                         argv[2][3] == 's' &&
 247                         argv[2][4] == 'h')
 248                 {
 249                         printf("Output will be flushed after every print.\n");
 250                         flushAfterWrite = 1;
 251                 }
 252                 else
 253                 marg.script_cmds_file = argv[2];
 254         }
 255
 256         // create a mutex to avoid interlacing print commands from our different threads
 257         pthread_mutex_init(&print_lock, NULL);
 258
 259         pthread_create(&main_loop_t, NULL, &main_loop, &marg);
 260         InitGraphics(argc, argv);
 261
 262         MainGraphics();
 263
 264         pthread_join(main_loop_t, NULL);
 265
 266         // Clean up the port
 267         uart_close(sp);
 268
 269         // clean up mutex
 270         pthread_mutex_destroy(&print_lock);
 271
 272   return 0;
 273 }