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