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>

20 #include "proxmark3.h"

21 #include "proxgui.h"

22 #include "cmdmain.h"

23 #include "uart.h"

24 #include "ui.h"

25 #include "cmdparser.h"

26 #include "cmdhw.h"

27 #include "whereami.h"

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

31 pthread_mutex_t print_lock;

33 static serial_port sp;

34 static UsbCommand txcmd;

 volatile static bool txcmd_pending = false;

 void SendCommand(UsbCommand *c) {

38 #if 0

                 printf("Sending %d bytes\n", sizeof(UsbCommand));

40 #endif

42 if (offline) {

43 PrintAndLog("Sending bytes to proxmark failed - offline");

44 return;

45 }

46 /**

47 The while-loop below causes hangups at times, when the pm3 unit is unresponsive

48 or disconnected. The main console thread is alive, but comm thread just spins here.

49 Not good.../holiman

50 **/

51 while(txcmd_pending);

52 txcmd = *c;

53 txcmd_pending = true;

54 }

56 struct receiver_arg {

57 int run;

58 };

60 struct main_loop_arg {

61 int usb_present;

62 char *script_cmds_file;

63 };

65 byte_t rx[0x1000000];

66 byte_t* prx = rx;

 static void *uart_receiver(void *targ) {

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

70 size_t rxlen;

71 size_t cmd_count;

73 while (arg->run) {

74 rxlen = sizeof(UsbCommand);

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

76 prx += rxlen;

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

78 continue;

79 }

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

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

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

84 }

85 }

86 prx = rx;

88 if(txcmd_pending) {

                         if (!uart_send(sp, (byte_t*) &txcmd, sizeof(UsbCommand))) {

90 PrintAndLog("Sending bytes to proxmark failed");

91 }

92 txcmd_pending = false;

93 }

94 }

96 pthread_exit(NULL);

97 return NULL;

98 }

 static void *main_loop(void *targ) {

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

102 struct receiver_arg rarg;

103 char *cmd = NULL;

104 pthread_t reader_thread;

105

         if (arg->usb_present == 1) {

107 rarg.run = 1;

                 pthread_create(&reader_thread, NULL, &uart_receiver, &rarg);

109 // cache Version information now:

110 CmdVersion(NULL);

111 }

112

113 FILE *script_file = NULL;

         char script_cmd_buf[256];  // iceman, needs lua script the same file_path_buffer as the rest

115

116 if (arg->script_cmds_file) {

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

118 if (script_file) {

                         printf("using 'scripting' commands file %s\n", arg->script_cmds_file);

120 }

121 }

122

123 read_history(".history");

124

125 while(1) {

126

127 // If there is a script file

128 if (script_file)

129 {

                         if (!fgets(script_cmd_buf, sizeof(script_cmd_buf), script_file)) {

131 fclose(script_file);

132 script_file = NULL;

133 } else {

134 char *nl;

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

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

137

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

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

140

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

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

143 strcpy(cmd, script_cmd_buf);

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

145 }

146 }

147 }

148

149 if (!script_file) {

150 cmd = readline(PROXPROMPT);

151 }

152

153 if (cmd) {

154

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

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

157

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

                                 int ret = CommandReceived(cmd);

160 add_history(cmd);

                                 if (ret == 99) {  // exit or quit

162 break;

163 }

164 }

165 free(cmd);

166 } else {

                         printf("\n");

168 break;

169 }

170 }

171

172 write_history(".history");

173

         if (arg->usb_present == 1) {

175 rarg.run = 0;

176 pthread_join(reader_thread, NULL);

177 }

178

179 ExitGraphics();

180

181 if (script_file) {

182 fclose(script_file);

183 script_file = NULL;

184 }

185 pthread_exit(NULL);

186 return NULL;

187 }

188

 static void dumpAllHelp(int markdown)

190 {

   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");

195 command_t *cmds = getTopLevelCommandTable();

196 dumpCommandsRecursive(cmds, markdown);

197 }

198

199 static char *my_executable_path = NULL;

200 static char *my_executable_directory = NULL;

201

 const char *get_my_executable_path(void)

203 {

204 return my_executable_path;

205 }

206

 const char *get_my_executable_directory(void)

208 {

209 return my_executable_directory;

210 }

211

 static void set_my_executable_path(void)

213 {

         int path_length = wai_getExecutablePath(NULL, 0, NULL);

         if (path_length != -1) {

                 my_executable_path = (char*)malloc(path_length + 1);

217 int dirname_length = 0;

                 if (wai_getExecutablePath(my_executable_path, path_length, &dirname_length) != -1) {

219 my_executable_path[path_length] = '\0';

                         my_executable_directory = (char *)malloc(dirname_length + 2);

                         strncpy(my_executable_directory, my_executable_path, dirname_length+1);

                         my_executable_directory[dirname_length+1] = '\0';

223 }

224 }

225 }

226

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

         srand(time(0));

229

         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");

237 return 1;

238 }

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

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

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

242 dumpAllHelp(0);

243 return 0;

244 }

         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_thread;

258

259

         sp = uart_open(argv[1]);

261 if (sp == INVALID_SERIAL_PORT) {

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

263 marg.usb_present = 0;

264 offline = 1;

         } else if (sp == CLAIMED_SERIAL_PORT) {

                 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

         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')

281 {

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

283 flushAfterWrite = 1;

284 }

285 else

                 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);

         pthread_create(&main_loop_thread, NULL, &main_loop, &marg);

292

293 // build ui/graph forms on separate thread (killed on main_loop_thread);

294 InitGraphics(argc, argv);

295 MainGraphics();

296 //this won't return until ExitGraphics() is called

297

298 //wait for thread to finish

299 pthread_join(main_loop_thread, NULL);

300

301

302 // Clean up the port

         if (offline == 0) {

304 uart_close(sp);

305 }

306

307 // clean up mutex

308 pthread_mutex_destroy(&print_lock);

309

310 exit(0);

311 }