git.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
  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         nl = strrchr(script_cmd_buf, '\n');
 135         if (nl) *nl = '\0';
 136
 137                                 if ((cmd = (char*) malloc(strlen(script_cmd_buf) + 1)) != NULL) {
 138           memset(cmd, 0, strlen(script_cmd_buf));
 139           strcpy(cmd, script_cmd_buf);
 140           printf("%s\n", cmd);
 141         }
 142       }
 143     }
 144
 145                 if (!script_file) {
 146       cmd = readline(PROXPROMPT);
 147                 }
 148
 149                 if (cmd) {
 150
 151                         while(cmd[strlen(cmd) - 1] == ' ')
 152         cmd[strlen(cmd) - 1] = 0x00;
 153
 154                         if (cmd[0] != 0x00) {
 155                                 if (strncmp(cmd, "quit", 4) == 0) {
 156                                         exit(0);
 157                                         break;
 158                                 }
 159                                 CommandReceived(cmd);
 160                                 add_history(cmd);
 161                         }
 162                         free(cmd);
 163                 } else {
 164                         printf("\n");
 165                         break;
 166                 }
 167         }
 168
 169         write_history(".history");
 170
 171   if (arg->usb_present == 1) {
 172     rarg.run = 0;
 173     pthread_join(reader_thread, NULL);
 174   }
 175
 176         if (script_file) {
 177     fclose(script_file);
 178     script_file = NULL;
 179   }
 180
 181   ExitGraphics();
 182   pthread_exit(NULL);
 183   return NULL;
 184 }
 185
 186 static void dumpAllHelp(int markdown)
 187 {
 188   printf("\n%sProxmark3 command dump%s\n\n",markdown?"# ":"",markdown?"":"\n======================");
 189   printf("Some commands are available only if a Proxmark is actually connected.%s\n",markdown?"  ":"");
 190   printf("Check column \"offline\" for their availability.\n");
 191   printf("\n");
 192   command_t *cmds = getTopLevelCommandTable();
 193   dumpCommandsRecursive(cmds, markdown);
 194 }
 195
 196 int main(int argc, char* argv[]) {
 197         srand(time(0));
 198
 199         if (argc < 2) {
 200                 printf("syntax: %s <port>\n\n",argv[0]);
 201                 printf("\tLinux example:'%s /dev/ttyACM0'\n\n", argv[0]);
 202                 printf("help:   %s -h\n\n", argv[0]);
 203                 printf("\tDump all interactive help at once\n");
 204                 printf("markdown:   %s -m\n\n", argv[0]);
 205                 printf("\tDump all interactive help at once in markdown syntax\n");
 206                 return 1;
 207         }
 208         if (strcmp(argv[1], "-h") == 0) {
 209                 printf("syntax: %s <port>\n\n",argv[0]);
 210                 printf("\tLinux example:'%s /dev/ttyACM0'\n\n", argv[0]);
 211                 dumpAllHelp(0);
 212                 return 0;
 213         }
 214         if (strcmp(argv[1], "-m") == 0) {
 215                 dumpAllHelp(1);
 216                 return 0;
 217         }
 218         // Make sure to initialize
 219         struct main_loop_arg marg = {
 220                 .usb_present = 0,
 221                 .script_cmds_file = NULL
 222         };
 223         pthread_t main_loop_t;
 224
 225
 226         sp = uart_open(argv[1]);
 227         if (sp == INVALID_SERIAL_PORT) {
 228                 printf("ERROR: invalid serial port\n");
 229                 marg.usb_present = 0;
 230                 offline = 1;
 231         } else if (sp == CLAIMED_SERIAL_PORT) {
 232                 printf("ERROR: serial port is claimed by another process\n");
 233                 marg.usb_present = 0;
 234                 offline = 1;
 235         } else {
 236                 marg.usb_present = 1;
 237                 offline = 0;
 238         }
 239
 240         // If the user passed the filename of the 'script' to execute, get it
 241         if (argc > 2 && argv[2]) {
 242                 if (argv[2][0] == 'f' &&  //buzzy, if a word 'flush' passed, flush the output after every log entry.
 243                         argv[2][1] == 'l' &&
 244                         argv[2][2] == 'u' &&
 245                         argv[2][3] == 's' &&
 246                         argv[2][4] == 'h')
 247                 {
 248                         printf("Output will be flushed after every print.\n");
 249                         flushAfterWrite = 1;
 250                 }
 251                 else
 252                 marg.script_cmds_file = argv[2];
 253         }
 254
 255         // create a mutex to avoid interlacing print commands from our different threads
 256         pthread_mutex_init(&print_lock, NULL);
 257
 258         pthread_create(&main_loop_t, NULL, &main_loop, &marg);
 259         InitGraphics(argc, argv);
 260
 261         MainGraphics();
 262
 263         pthread_join(main_loop_t, NULL);
 264
 265         // Clean up the port
 266         uart_close(sp);
 267
 268         // clean up mutex
 269         pthread_mutex_destroy(&print_lock);
 270
 271   return 0;
 272 }