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 (txcmd_pending) {
  42     ERR("Sending command failed, previous command is still pending");
  43   }
  44 */
  45   if(offline)
  46     {
  47       PrintAndLog("Sending bytes to proxmark failed - offline");
  48       return;
  49     }
  50   /**
  51         The while-loop below causes hangups at times, when the pm3 unit is unresponsive
  52         or disconnected. The main console thread is alive, but comm thread just spins here.
  53         Not good.../holiman
  54         **/
  55   while(txcmd_pending);
  56   txcmd = *c;
  57   txcmd_pending = true;
  58 }
  59
  60 struct receiver_arg {
  61   int run;
  62 };
  63
  64 struct main_loop_arg {
  65   int usb_present;
  66   char *script_cmds_file;
  67 };
  68
  69 //static void *usb_receiver(void *targ) {
  70 //  struct receiver_arg *arg = (struct receiver_arg*)targ;
  71 //  UsbCommand cmdbuf;
  72 //
  73 //  while (arg->run) {
  74 //    if (ReceiveCommandPoll(&cmdbuf)) {
  75 //      UsbCommandReceived(&cmdbuf);
  76 //      fflush(NULL);
  77 //    }
  78 //  }
  79 //
  80 //  pthread_exit(NULL);
  81 //  return NULL;
  82 //}
  83
  84 byte_t rx[0x1000000];
  85 byte_t* prx = rx;
  86
  87 static void *uart_receiver(void *targ) {
  88   struct receiver_arg *arg = (struct receiver_arg*)targ;
  89   size_t rxlen;
  90   size_t cmd_count;
  91
  92   while (arg->run) {
  93     rxlen = sizeof(UsbCommand);
  94     if (uart_receive(sp,prx,&rxlen)) {
  95       prx += rxlen;
  96       if (((prx-rx) % sizeof(UsbCommand)) != 0) {
  97         continue;
  98       }
  99       cmd_count = (prx-rx) / sizeof(UsbCommand);
 100       //      printf("received %d bytes, which represents %d commands\n",(prx-rx), cmd_count);
 101       for (size_t i=0; i<cmd_count; i++) {
 102         UsbCommandReceived((UsbCommand*)(rx+(i*sizeof(UsbCommand))));
 103       }
 104     }
 105     prx = rx;
 106
 107     if(txcmd_pending) {
 108       if (!uart_send(sp,(byte_t*)&txcmd,sizeof(UsbCommand))) {
 109         PrintAndLog("Sending bytes to proxmark failed");
 110       }
 111       txcmd_pending = false;
 112     }
 113   }
 114
 115   pthread_exit(NULL);
 116   return NULL;
 117 }
 118
 119 static void *main_loop(void *targ) {
 120   struct main_loop_arg *arg = (struct main_loop_arg*)targ;
 121   struct receiver_arg rarg;
 122   char *cmd = NULL;
 123   pthread_t reader_thread;
 124
 125   if (arg->usb_present == 1) {
 126     rarg.run=1;
 127     // pthread_create(&reader_thread, NULL, &usb_receiver, &rarg);
 128     pthread_create(&reader_thread, NULL, &uart_receiver, &rarg);
 129   }
 130
 131   FILE *script_file = NULL;
 132   char script_cmd_buf[256];
 133
 134   if (arg->script_cmds_file)
 135   {
 136     script_file = fopen(arg->script_cmds_file, "r");
 137     if (script_file)
 138     {
 139       printf("using 'scripting' commands file %s\n", arg->script_cmds_file);
 140     }
 141   }
 142
 143         read_history(".history");
 144         while(1)
 145   {
 146     // If there is a script file
 147     if (script_file)
 148     {
 149       if (!fgets(script_cmd_buf, sizeof(script_cmd_buf), script_file))
 150       {
 151         fclose(script_file);
 152         script_file = NULL;
 153       }
 154       else
 155       {
 156         char *nl;
 157         nl = strrchr(script_cmd_buf, '\r');
 158         if (nl) *nl = '\0';
 159         nl = strrchr(script_cmd_buf, '\n');
 160         if (nl) *nl = '\0';
 161
 162         if ((cmd = (char*) malloc(strlen(script_cmd_buf) + 1)) != NULL)
 163         {
 164           memset(cmd, 0, strlen(script_cmd_buf));
 165           strcpy(cmd, script_cmd_buf);
 166           printf("%s\n", cmd);
 167         }
 168       }
 169     }
 170
 171                 if (!script_file)
 172                 {
 173       cmd = readline(PROXPROMPT);
 174                 }
 175
 176                 if (cmd) {
 177                         while(cmd[strlen(cmd) - 1] == ' ')
 178         cmd[strlen(cmd) - 1] = 0x00;
 179
 180                         if (cmd[0] != 0x00) {
 181                                 if (strncmp(cmd, "quit", 4) == 0) {
 182                                         exit(0);
 183                                         break;
 184                                 }
 185
 186                                 CommandReceived(cmd);
 187                                 add_history(cmd);
 188                         }
 189                         free(cmd);
 190                 } else {
 191                         printf("\n");
 192                         break;
 193                 }
 194         }
 195
 196         write_history(".history");
 197
 198   if (arg->usb_present == 1) {
 199     rarg.run = 0;
 200     pthread_join(reader_thread, NULL);
 201   }
 202
 203   if (script_file)
 204   {
 205     fclose(script_file);
 206     script_file = NULL;
 207   }
 208
 209   ExitGraphics();
 210   pthread_exit(NULL);
 211   return NULL;
 212 }
 213
 214 //static void dumpHelp(char  *parent, ...)
 215 //{
 216 //  printf("## %s\n\n", parent);
 217 //  CommandReceived(parent);
 218 //
 219 //  printf("\n");
 220 //}
 221
 222 static void dumpAllHelp(int markdown)
 223 {
 224   printf("\n%sProxmark3 command dump%s\n\n",markdown?"# ":"",markdown?"":"\n======================");
 225   printf("Some commands are available only if a Proxmark is actually connected.%s\n",markdown?"  ":"");
 226   printf("Check column \"offline\" for their availability.\n");
 227   printf("\n");
 228   command_t *cmds = getTopLevelCommandTable();
 229   dumpCommandsRecursive(cmds, markdown);
 230 }
 231
 232 int main(int argc, char* argv[]) {
 233         srand(time(0));
 234
 235         if (argc < 2) {
 236                 printf("syntax: %s <port>\n\n",argv[0]);
 237                 printf("\tLinux example:'%s /dev/ttyACM0'\n\n", argv[0]);
 238                 printf("help:   %s -h\n\n", argv[0]);
 239                 printf("\tDump all interactive help at once\n");
 240                 printf("markdown:   %s -m\n\n", argv[0]);
 241                 printf("\tDump all interactive help at once in markdown syntax\n");
 242                 return 1;
 243         }
 244         if (strcmp(argv[1], "-h") == 0) {
 245                 printf("syntax: %s <port>\n\n",argv[0]);
 246                 printf("\tLinux example:'%s /dev/ttyACM0'\n\n", argv[0]);
 247                 dumpAllHelp(0);
 248                 return 0;
 249         }
 250         if (strcmp(argv[1], "-m") == 0) {
 251                 dumpAllHelp(1);
 252                 return 0;
 253         }
 254         // Make sure to initialize
 255         struct main_loop_arg marg = {
 256                 .usb_present = 0,
 257                 .script_cmds_file = NULL
 258         };
 259         pthread_t main_loop_t;
 260
 261 /*
 262   usb_init();
 263   if (!OpenProxmark(1)) {
 264     fprintf(stderr,"PROXMARK3: NOT FOUND!\n");
 265     marg.usb_present = 0;
 266     offline = 1;
 267   } else {
 268     marg.usb_present = 1;
 269     offline = 0;
 270   }
 271 */
 272
 273         sp = uart_open(argv[1]);
 274         if (sp == INVALID_SERIAL_PORT) {
 275                 printf("ERROR: invalid serial port\n");
 276                 marg.usb_present = 0;
 277                 offline = 1;
 278         } else if (sp == CLAIMED_SERIAL_PORT) {
 279                 printf("ERROR: serial port is claimed by another process\n");
 280                 marg.usb_present = 0;
 281                 offline = 1;
 282         } else {
 283                 marg.usb_present = 1;
 284                 offline = 0;
 285         }
 286
 287         // If the user passed the filename of the 'script' to execute, get it
 288         if (argc > 2 && argv[2]) {
 289                 if (argv[2][0] == 'f' &&  //buzzy, if a word 'flush' passed, flush the output after every log entry.
 290                         argv[2][1] == 'l' &&
 291                         argv[2][2] == 'u' &&
 292                         argv[2][3] == 's' &&
 293                         argv[2][4] == 'h')
 294                 {
 295                         printf("Output will be flushed after every print.\n");
 296                         flushAfterWrite = 1;
 297                 }
 298                 else
 299                 marg.script_cmds_file = argv[2];
 300         }
 301
 302         // create a mutex to avoid interlacing print commands from our different threads
 303         pthread_mutex_init(&print_lock, NULL);
 304
 305         pthread_create(&main_loop_t, NULL, &main_loop, &marg);
 306         InitGraphics(argc, argv);
 307
 308         MainGraphics();
 309
 310         pthread_join(main_loop_t, NULL);
 311
 312 //  if (marg.usb_present == 1) {
 313 //    CloseProxmark();
 314 //  }
 315
 316         // Clean up the port
 317         uart_close(sp);
 318
 319         // clean up mutex
 320         pthread_mutex_destroy(&print_lock);
 321
 322   return 0;
 323 }