git.zerfleddert.de Git - proxmark3-svn/blob

1 //-----------------------------------------------------------------------------

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 //-----------------------------------------------------------------------------

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"

29 // a global mutex to prevent interlaced printing from different threads

30 pthread_mutex_t print_lock;

32 static serial_port sp;

33 static UsbCommand txcmd;

 volatile static bool txcmd_pending = false;

 void SendCommand(UsbCommand *c) {

37 #if 0

   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 }

60 struct receiver_arg {

61 int run;

62 };

64 struct main_loop_arg {

65 int usb_present;

66 char *script_cmds_file;

67 };

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 //}

84 byte_t rx[0x1000000];

85 byte_t* prx = rx;

 static void *uart_receiver(void *targ) {

   struct receiver_arg *arg = (struct receiver_arg*)targ;

89 size_t rxlen;

90 size_t cmd_count;

92 while (arg->run) {

93 rxlen = sizeof(UsbCommand);

     if (uart_receive(sp,prx,&rxlen)) {

95 prx += rxlen;

       if (((prx-rx) % sizeof(UsbCommand)) != 0) {

97 continue;

98 }

       cmd_count = (prx-rx) / sizeof(UsbCommand);

100 // printf("received %d bytes, which represents %d commands\n",(prx-rx), cmd_count);

       for (size_t i=0; i<cmd_count; i++) {

         UsbCommandReceived((UsbCommand*)(rx+(i*sizeof(UsbCommand))));

103 }

104 }

105 prx = rx;

106

107 if(txcmd_pending) {

       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

 static void *main_loop(void *targ) {

   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

   if (arg->usb_present == 1) {

126 rarg.run=1;

127 // pthread_create(&reader_thread, NULL, &usb_receiver, &rarg);

     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 {

     script_file = fopen(arg->script_cmds_file, "r");

137 if (script_file)

138 {

       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 {

       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;

         nl = strrchr(script_cmd_buf, '\r');

         if (nl) *nl = '\0';

         nl = strrchr(script_cmd_buf, '\n');

         if (nl) *nl = '\0';

161

         if ((cmd = (char*) malloc(strlen(script_cmd_buf) + 1)) != NULL)

163 {

           memset(cmd, 0, strlen(script_cmd_buf));

165 strcpy(cmd, script_cmd_buf);

           printf("%s\n", cmd);

167 }

168 }

169 }

170

171 if (!script_file)

172 {

173 cmd = readline(PROXPROMPT);

174 }

175

176 if (cmd) {

                         while(cmd[strlen(cmd) - 1] == ' ')

         cmd[strlen(cmd) - 1] = 0x00;

179

                         if (cmd[0] != 0x00) {

                                 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 {

                         printf("\n");

192 break;

193 }

194 }

195

196 write_history(".history");

197

   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

 static void dumpAllHelp(int markdown)

223 {

   printf("\n%sProxmark3 command dump%s\n\n",markdown?"# ":"",markdown?"":"\n======================");

   printf("Some commands are available only if a Proxmark is actually connected.%s\n",markdown?"  ":"");

   printf("Check column \"offline\" for their availability.\n");

   printf("\n");

228 command_t *cmds = getTopLevelCommandTable();

229 dumpCommandsRecursive(cmds, markdown);

230 }

231

 int main(int argc, char* argv[]) {

         srand(time(0));

234

         if (argc < 2) {

                 printf("syntax: %s <port>\n\n",argv[0]);

                 printf("\tLinux example:'%s /dev/ttyACM0'\n\n", argv[0]);

                 printf("help:   %s -h\n\n", argv[0]);

                 printf("\tDump all interactive help at once\n");

                 printf("markdown:   %s -m\n\n", argv[0]);

                 printf("\tDump all interactive help at once in markdown syntax\n");

242 return 1;

243 }

         if (strcmp(argv[1], "-h") == 0) {

                 printf("syntax: %s <port>\n\n",argv[0]);

                 printf("\tLinux example:'%s /dev/ttyACM0'\n\n", argv[0]);

247 dumpAllHelp(0);

248 return 0;

249 }

         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

         sp = uart_open(argv[1]);

274 if (sp == INVALID_SERIAL_PORT) {

                 printf("ERROR: invalid serial port\n");

276 marg.usb_present = 0;

277 offline = 1;

         } else if (sp == CLAIMED_SERIAL_PORT) {

                 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

         if (argc > 2 && argv[2]) {

                 if (argv[2][0] == 'f' &&  //buzzy, if a word 'flush' passed, flush the output after every log entry.

                         argv[2][1] == 'l' &&

                         argv[2][2] == 'u' &&

                         argv[2][3] == 's' &&

                         argv[2][4] == 'h')

294 {

                         printf("Output will be flushed after every print.\n");

296 flushAfterWrite = 1;

297 }

298 else

                 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

         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 }