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