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 //#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
  27 static serial_port sp;
  28 static UsbCommand txcmd;
  29 static bool txcmd_pending = false;
  30
  31 void SendCommand(UsbCommand *c) {
  32 #if 0
  33   printf("Sending %d bytes\n", sizeof(UsbCommand));
  34 #endif
  35 /*
  36   if (txcmd_pending) {
  37     ERR("Sending command failed, previous command is still pending");
  38   }
  39 */
  40   while(txcmd_pending);
  41   txcmd = *c;
  42   txcmd_pending = true;
  43 }
  44
  45 struct receiver_arg {
  46   int run;
  47 };
  48
  49 struct main_loop_arg {
  50   int usb_present;
  51   char *script_cmds_file;
  52 };
  53
  54 //static void *usb_receiver(void *targ) {
  55 //  struct receiver_arg *arg = (struct receiver_arg*)targ;
  56 //  UsbCommand cmdbuf;
  57 //
  58 //  while (arg->run) {
  59 //    if (ReceiveCommandPoll(&cmdbuf)) {
  60 //      UsbCommandReceived(&cmdbuf);
  61 //      fflush(NULL);
  62 //    }
  63 //  }
  64 //
  65 //  pthread_exit(NULL);
  66 //  return NULL;
  67 //}
  68
  69 byte_t rx[0x1000000];
  70 byte_t* prx = rx;
  71
  72 static void *uart_receiver(void *targ) {
  73   struct receiver_arg *arg = (struct receiver_arg*)targ;
  74   size_t rxlen;
  75   size_t cmd_count;
  76
  77   while (arg->run) {
  78     rxlen = sizeof(UsbCommand);
  79     if (uart_receive(sp,prx,&rxlen)) {
  80       prx += rxlen;
  81       if (((prx-rx) % sizeof(UsbCommand)) != 0) {
  82         continue;
  83       }
  84       cmd_count = (prx-rx) / sizeof(UsbCommand);
  85       //      printf("received %d bytes, which represents %d commands\n",(prx-rx), cmd_count);
  86       for (size_t i=0; i<cmd_count; i++) {
  87         UsbCommandReceived((UsbCommand*)(rx+(i*sizeof(UsbCommand))));
  88       }
  89     }
  90     prx = rx;
  91
  92     if(txcmd_pending) {
  93       if (!uart_send(sp,(byte_t*)&txcmd,sizeof(UsbCommand))) {
  94         PrintAndLog("Sending bytes to proxmark failed");
  95       }
  96       txcmd_pending = false;
  97     }
  98   }
  99
 100   pthread_exit(NULL);
 101   return NULL;
 102 }
 103
 104 static void *main_loop(void *targ) {
 105   struct main_loop_arg *arg = (struct main_loop_arg*)targ;
 106   struct receiver_arg rarg;
 107   char *cmd = NULL;
 108   pthread_t reader_thread;
 109
 110   if (arg->usb_present == 1) {
 111     rarg.run=1;
 112     // pthread_create(&reader_thread, NULL, &usb_receiver, &rarg);
 113     pthread_create(&reader_thread, NULL, &uart_receiver, &rarg);
 114   }
 115
 116   FILE *script_file = NULL;
 117   char script_cmd_buf[256];
 118
 119   if (arg->script_cmds_file)
 120   {
 121     script_file = fopen(arg->script_cmds_file, "r");
 122     if (script_file)
 123     {
 124       printf("using 'scripting' commands file %s\n", arg->script_cmds_file);
 125     }
 126   }
 127
 128         read_history(".history");
 129         while(1)
 130   {
 131     // If there is a script file
 132     if (script_file)
 133     {
 134       if (!fgets(script_cmd_buf, sizeof(script_cmd_buf), script_file))
 135       {
 136         fclose(script_file);
 137         script_file = NULL;
 138       }
 139       else
 140       {
 141         char *nl;
 142         nl = strrchr(script_cmd_buf, '\r');
 143         if (nl) *nl = '\0';
 144         nl = strrchr(script_cmd_buf, '\n');
 145         if (nl) *nl = '\0';
 146
 147         if ((cmd = (char*) malloc(strlen(script_cmd_buf) + 1)) != NULL)
 148         {
 149           memset(cmd, 0, strlen(script_cmd_buf));
 150           strcpy(cmd, script_cmd_buf);
 151           printf("%s\n", cmd);
 152         }
 153       }
 154     }
 155
 156                 if (!script_file)
 157                 {
 158       cmd = readline(PROXPROMPT);
 159                 }
 160
 161                 if (cmd) {
 162                         while(cmd[strlen(cmd) - 1] == ' ')
 163         cmd[strlen(cmd) - 1] = 0x00;
 164
 165                         if (cmd[0] != 0x00) {
 166                                 if (strncmp(cmd, "quit", 4) == 0) {
 167                                         break;
 168                                 }
 169
 170                                 CommandReceived(cmd);
 171                                 add_history(cmd);
 172                         }
 173                         free(cmd);
 174                 } else {
 175                         printf("\n");
 176                         break;
 177                 }
 178         }
 179
 180         write_history(".history");
 181
 182   if (arg->usb_present == 1) {
 183     rarg.run = 0;
 184     pthread_join(reader_thread, NULL);
 185   }
 186
 187   if (script_file)
 188   {
 189     fclose(script_file);
 190     script_file = NULL;
 191   }
 192
 193   ExitGraphics();
 194   pthread_exit(NULL);
 195   return NULL;
 196 }
 197
 198 int main(int argc, char* argv[]) {
 199   srand(time(0));
 200
 201   if (argc < 2) {
 202     printf("syntax: %s <port>\n\n",argv[0]);
 203     return 1;
 204   }
 205
 206   // Make sure to initialize
 207   struct main_loop_arg marg = {
 208     .usb_present = 0,
 209     .script_cmds_file = NULL
 210   };
 211   pthread_t main_loop_t;
 212
 213 /*
 214   usb_init();
 215   if (!OpenProxmark(1)) {
 216     fprintf(stderr,"PROXMARK3: NOT FOUND!\n");
 217     marg.usb_present = 0;
 218     offline = 1;
 219   } else {
 220     marg.usb_present = 1;
 221     offline = 0;
 222   }
 223 */
 224
 225   sp = uart_open(argv[1]);
 226   if (sp == INVALID_SERIAL_PORT) {
 227     printf("ERROR: invalid serial port\n");
 228     marg.usb_present = 0;
 229     offline = 1;
 230   } else if (sp == CLAIMED_SERIAL_PORT) {
 231     printf("ERROR: serial port is claimed by another process\n");
 232     marg.usb_present = 0;
 233     offline = 1;
 234   } else {
 235     marg.usb_present = 1;
 236     offline = 0;
 237   }
 238
 239   // If the user passed the filename of the 'script' to execute, get it
 240   if (argc > 2 && argv[2]) {
 241     marg.script_cmds_file = argv[2];
 242   }
 243
 244   pthread_create(&main_loop_t, NULL, &main_loop, &marg);
 245   InitGraphics(argc, argv);
 246
 247   MainGraphics();
 248
 249   pthread_join(main_loop_t, NULL);
 250
 251 //  if (marg.usb_present == 1) {
 252 //    CloseProxmark();
 253 //  }
 254
 255   // Clean up the port
 256   uart_close(sp);
 257
 258   return 0;
 259 }