211c4ba6c5d0d44e46a8ef3b75810e12ab7cfe4f
[openocd.git] / src / helper / ioutil.c
1 /***************************************************************************
2 * Copyright (C) 2007-2010 by √ėyvind Harboe *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
18 ***************************************************************************/
19
20 /* this file contains various functionality useful to standalone systems */
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25
26 #include "log.h"
27 #include "time_support.h"
28
29 #ifdef HAVE_ARPA_INET_H
30 #include <arpa/inet.h>
31 #endif
32 #ifdef HAVE_DIRENT_H
33 #include <dirent.h>
34 #endif
35 #ifdef HAVE_NETDB_H
36 #include <netdb.h>
37 #endif
38 #ifdef HAVE_NET_IF_H
39 #include <net/if.h>
40 #endif
41 #ifdef HAVE_SYS_IOCTL_H
42 #include <sys/ioctl.h>
43 #endif
44 #ifdef HAVE_SYS_STAT_H
45 #include <sys/stat.h>
46 #endif
47 #ifdef HAVE_IFADDRS_H
48 #include <ifaddrs.h>
49 #endif
50 #ifdef HAVE_MALLOC_H
51 #if !BUILD_ECOSBOARD
52 #include <malloc.h>
53 #endif
54 #endif
55
56
57 /* loads a file and returns a pointer to it in memory. The file contains
58 * a 0 byte(sentinel) after len bytes - the length of the file. */
59 int loadFile(const char *fileName, void **data, size_t *len)
60 {
61 // ensure returned length is always sane
62 *len = 0;
63
64 FILE * pFile;
65 pFile = fopen(fileName,"rb");
66 if (pFile == NULL)
67 {
68 LOG_ERROR("Can't open %s", fileName);
69 return ERROR_FAIL;
70 }
71 if (fseek(pFile, 0, SEEK_END) != 0)
72 {
73 LOG_ERROR("Can't open %s", fileName);
74 fclose(pFile);
75 return ERROR_FAIL;
76 }
77 long fsize = ftell(pFile);
78 if (fsize == -1)
79 {
80 LOG_ERROR("Can't open %s", fileName);
81 fclose(pFile);
82 return ERROR_FAIL;
83 }
84 *len = fsize;
85
86 if (fseek(pFile, 0, SEEK_SET) != 0)
87 {
88 LOG_ERROR("Can't open %s", fileName);
89 fclose(pFile);
90 return ERROR_FAIL;
91 }
92 *data = malloc(*len + 1);
93 if (*data == NULL)
94 {
95 LOG_ERROR("Can't open %s", fileName);
96 fclose(pFile);
97 return ERROR_FAIL;
98 }
99
100 if (fread(*data, 1, *len, pFile)!=*len)
101 {
102 fclose(pFile);
103 free(*data);
104 LOG_ERROR("Can't open %s", fileName);
105 return ERROR_FAIL;
106 }
107 fclose(pFile);
108
109 // 0-byte after buffer (not included in *len) serves as a sentinel
110 char *buf = (char *)*data;
111 buf[*len] = 0;
112
113 return ERROR_OK;
114 }
115
116 COMMAND_HANDLER(handle_cat_command)
117 {
118 if (CMD_ARGC != 1)
119 {
120 command_print(CMD_CTX, "cat <filename>");
121 return ERROR_INVALID_ARGUMENTS;
122 }
123
124 // NOTE!!! we only have line printing capability so we print the entire file as a single line.
125 void *data;
126 size_t len;
127
128 int retval = loadFile(CMD_ARGV[0], &data, &len);
129 if (retval == ERROR_OK)
130 {
131 command_print(CMD_CTX, "%s", (char *)data);
132 free(data);
133 }
134 else
135 {
136 command_print(CMD_CTX, "%s not found", CMD_ARGV[0]);
137 }
138
139 return ERROR_OK;
140 }
141
142 COMMAND_HANDLER(handle_trunc_command)
143 {
144 if (CMD_ARGC != 1)
145 {
146 command_print(CMD_CTX, "trunc <filename>");
147 return ERROR_INVALID_ARGUMENTS;
148 }
149
150 FILE *config_file = NULL;
151 config_file = fopen(CMD_ARGV[0], "w");
152 if (config_file != NULL)
153 fclose(config_file);
154
155 return ERROR_OK;
156 }
157
158 COMMAND_HANDLER(handle_meminfo_command)
159 {
160 static int prev = 0;
161 struct mallinfo info;
162
163 if (CMD_ARGC != 0)
164 {
165 command_print(CMD_CTX, "meminfo");
166 return ERROR_INVALID_ARGUMENTS;
167 }
168
169 info = mallinfo();
170
171 if (prev > 0)
172 {
173 command_print(CMD_CTX, "Diff: %d", prev - info.fordblks);
174 }
175 prev = info.fordblks;
176
177 command_print(CMD_CTX, "Available ram: %d", info.fordblks);
178
179 return ERROR_OK;
180 }
181
182
183 COMMAND_HANDLER(handle_append_command)
184 {
185 if (CMD_ARGC < 1)
186 {
187 command_print(CMD_CTX,
188 "append <filename> [<string1>, [<string2>, ...]]");
189 return ERROR_INVALID_ARGUMENTS;
190 }
191
192 int retval = ERROR_FAIL;
193 FILE *config_file = NULL;
194
195 config_file = fopen(CMD_ARGV[0], "a");
196 if (config_file != NULL)
197 {
198 fseek(config_file, 0, SEEK_END);
199
200 unsigned i;
201 for (i = 1; i < CMD_ARGC; i++)
202 {
203 if (fwrite(CMD_ARGV[i], 1, strlen(CMD_ARGV[i]),
204 config_file) != strlen(CMD_ARGV[i]))
205 break;
206 if (i != CMD_ARGC - 1)
207 {
208 if (fwrite(" ", 1, 1, config_file) != 1)
209 break;
210 }
211 }
212 if ((i == CMD_ARGC) && (fwrite("\n", 1, 1, config_file) == 1))
213 retval = ERROR_OK;
214
215 fclose(config_file);
216 }
217
218 return retval;
219 }
220
221
222
223 COMMAND_HANDLER(handle_cp_command)
224 {
225 if (CMD_ARGC != 2)
226 {
227 return ERROR_INVALID_ARGUMENTS;
228 }
229
230 // NOTE!!! we only have line printing capability so we print the entire file as a single line.
231 void *data;
232 size_t len;
233
234 int retval = loadFile(CMD_ARGV[0], &data, &len);
235 if (retval != ERROR_OK)
236 return retval;
237
238 FILE *f = fopen(CMD_ARGV[1], "wb");
239 if (f == NULL)
240 retval = ERROR_INVALID_ARGUMENTS;
241
242 size_t pos = 0;
243 for (;;)
244 {
245 size_t chunk = len - pos;
246 static const size_t maxChunk = 512 * 1024; // ~1/sec
247 if (chunk > maxChunk)
248 {
249 chunk = maxChunk;
250 }
251
252 if ((retval == ERROR_OK) && (fwrite(((char *)data) + pos, 1, chunk, f) != chunk))
253 retval = ERROR_INVALID_ARGUMENTS;
254
255 if (retval != ERROR_OK)
256 {
257 break;
258 }
259
260 command_print(CMD_CTX, "%zu", len - pos);
261
262 pos += chunk;
263
264 if (pos == len)
265 break;
266 }
267
268 if (retval == ERROR_OK)
269 {
270 command_print(CMD_CTX, "Copied %s to %s", CMD_ARGV[0], CMD_ARGV[1]);
271 } else
272 {
273 command_print(CMD_CTX, "copy failed");
274 }
275
276 if (data != NULL)
277 free(data);
278 if (f != NULL)
279 fclose(f);
280
281 if (retval != ERROR_OK)
282 unlink(CMD_ARGV[1]);
283
284 return retval;
285 }
286
287
288
289
290 #define SHOW_RESULT(a, b) LOG_ERROR(#a " failed %d\n", (int)b)
291
292 #define IOSIZE 512
293 void copyfile(char *name2, char *name1)
294 {
295
296 int err;
297 char buf[IOSIZE];
298 int fd1, fd2;
299 ssize_t done, wrote;
300
301 fd1 = open(name1, O_WRONLY | O_CREAT, 0664);
302 if (fd1 < 0)
303 SHOW_RESULT(open, fd1);
304
305 fd2 = open(name2, O_RDONLY);
306 if (fd2 < 0)
307 SHOW_RESULT(open, fd2);
308
309 for (;;)
310 {
311 done = read(fd2, buf, IOSIZE);
312 if (done < 0)
313 {
314 SHOW_RESULT(read, done);
315 break;
316 }
317
318 if (done == 0) break;
319
320 wrote = write(fd1, buf, done);
321 if (wrote != done) SHOW_RESULT(write, wrote);
322
323 if (wrote != done) break;
324 }
325
326 err = close(fd1);
327 if (err < 0) SHOW_RESULT(close, err);
328
329 err = close(fd2);
330 if (err < 0) SHOW_RESULT(close, err);
331
332 }
333
334 /* utility fn to copy a directory */
335 void copydir(char *name, char *destdir)
336 {
337 int err;
338 DIR *dirp;
339
340 dirp = opendir(destdir);
341 if (dirp == NULL)
342 {
343 mkdir(destdir, 0777);
344 } else
345 {
346 err = closedir(dirp);
347 }
348
349 dirp = opendir(name);
350 if (dirp == NULL) SHOW_RESULT(opendir, -1);
351
352 for (;;)
353 {
354 struct dirent *entry = readdir(dirp);
355
356 if (entry == NULL)
357 break;
358
359 if (strcmp(entry->d_name, ".") == 0)
360 continue;
361 if (strcmp(entry->d_name, "..") == 0)
362 continue;
363
364 int isDir = 0;
365 struct stat buf;
366 char fullPath[PATH_MAX];
367 strncpy(fullPath, name, PATH_MAX);
368 strcat(fullPath, "/");
369 strncat(fullPath, entry->d_name, PATH_MAX - strlen(fullPath));
370
371 if (stat(fullPath, &buf) == -1)
372 {
373 LOG_ERROR("unable to read status from %s", fullPath);
374 break;
375 }
376 isDir = S_ISDIR(buf.st_mode) != 0;
377
378 if (isDir)
379 continue;
380
381 // diag_printf("<INFO>: entry %14s",entry->d_name);
382 char fullname[PATH_MAX];
383 char fullname2[PATH_MAX];
384
385 strcpy(fullname, name);
386 strcat(fullname, "/");
387 strcat(fullname, entry->d_name);
388
389 strcpy(fullname2, destdir);
390 strcat(fullname2, "/");
391 strcat(fullname2, entry->d_name);
392 // diag_printf("from %s to %s\n", fullname, fullname2);
393 copyfile(fullname, fullname2);
394
395 // diag_printf("\n");
396 }
397
398 err = closedir(dirp);
399 if (err < 0) SHOW_RESULT(stat, err);
400 }
401
402
403
404
405 COMMAND_HANDLER(handle_rm_command)
406 {
407 if (CMD_ARGC != 1)
408 return ERROR_INVALID_ARGUMENTS;
409
410 bool del = false;
411 if (rmdir(CMD_ARGV[0]) == 0)
412 del = true;
413 else if (unlink(CMD_ARGV[0]) == 0)
414 del = true;
415
416 return del ? ERROR_OK : ERROR_FAIL;
417 }
418
419
420 static int
421 ioutil_Jim_Command_ls(Jim_Interp *interp,
422 int argc,
423 Jim_Obj * const *argv)
424 {
425 if (argc != 2)
426 {
427 Jim_WrongNumArgs(interp, 1, argv, "ls ?dir?");
428 return JIM_ERR;
429 }
430
431 char *name = (char*) Jim_GetString(argv[1], NULL);
432
433 DIR *dirp = NULL;
434 dirp = opendir(name);
435 if (dirp == NULL)
436 {
437 return JIM_ERR;
438 }
439 Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0);
440
441 for (;;)
442 {
443 struct dirent *entry = NULL;
444 entry = readdir(dirp);
445 if (entry == NULL)
446 break;
447
448 if ((strcmp(".", entry->d_name) == 0)||(strcmp("..", entry->d_name) == 0))
449 continue;
450
451 Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, entry->d_name, strlen(entry->d_name)));
452 }
453 closedir(dirp);
454
455 Jim_SetResult(interp, objPtr);
456
457 return JIM_OK;
458 }
459
460 static int
461 ioutil_Jim_Command_peek(Jim_Interp *interp,
462 int argc,
463 Jim_Obj * const *argv)
464 {
465 if (argc != 2)
466 {
467 Jim_WrongNumArgs(interp, 1, argv, "peek ?address?");
468 return JIM_ERR;
469 }
470
471 long address;
472 if (Jim_GetLong(interp, argv[1], &address) != JIM_OK)
473 return JIM_ERR;
474
475 int value = *((volatile int *) address);
476
477 Jim_SetResult(interp, Jim_NewIntObj(interp, value));
478
479 return JIM_OK;
480 }
481
482 static int
483 ioutil_Jim_Command_poke(Jim_Interp *interp,
484 int argc,
485 Jim_Obj * const *argv)
486 {
487 if (argc != 3)
488 {
489 Jim_WrongNumArgs(interp, 1, argv, "poke ?address? ?value?");
490 return JIM_ERR;
491 }
492
493 long address;
494 if (Jim_GetLong(interp, argv[1], &address) != JIM_OK)
495 return JIM_ERR;
496 long value;
497 if (Jim_GetLong(interp, argv[2], &value) != JIM_OK)
498 return JIM_ERR;
499
500 *((volatile int *) address) = value;
501
502 return JIM_OK;
503 }
504
505
506 /* not so pretty code to fish out ip number*/
507 static int ioutil_Jim_Command_ip(Jim_Interp *interp, int argc,
508 Jim_Obj * const *argv)
509 {
510 #if !defined(__CYGWIN__)
511 Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
512
513 struct ifaddrs *ifa = NULL, *ifp = NULL;
514
515 if (getifaddrs(&ifp) < 0)
516 {
517 return JIM_ERR;
518 }
519
520 for (ifa = ifp; ifa; ifa = ifa->ifa_next)
521 {
522 char ip[200];
523 socklen_t salen;
524
525 if (ifa->ifa_addr->sa_family == AF_INET)
526 salen = sizeof(struct sockaddr_in);
527 else if (ifa->ifa_addr->sa_family == AF_INET6)
528 salen = sizeof(struct sockaddr_in6);
529 else
530 continue;
531
532 if (getnameinfo(ifa->ifa_addr, salen, ip, sizeof(ip), NULL, 0,
533 NI_NUMERICHOST) < 0)
534 {
535 continue;
536 }
537
538 Jim_AppendString(interp, tclOutput, ip, strlen(ip));
539 break;
540
541 }
542
543 freeifaddrs(ifp);
544 #else
545 Jim_Obj *tclOutput = Jim_NewStringObj(interp, "fixme!!!", 0);
546 LOG_ERROR("NOT IMPLEMENTED!!!");
547 #endif
548 Jim_SetResult(interp, tclOutput);
549
550 return JIM_OK;
551 }
552
553 /* not so pretty code to fish out eth0 mac address */
554 static int ioutil_Jim_Command_mac(Jim_Interp *interp, int argc,
555 Jim_Obj * const *argv)
556 {
557
558
559 struct ifreq *ifr, *ifend;
560 struct ifreq ifreq;
561 struct ifconf ifc;
562 struct ifreq ifs[5];
563 int SockFD;
564
565 SockFD = socket(AF_INET, SOCK_DGRAM, 0);
566 if (SockFD < 0)
567 {
568 return JIM_ERR;
569 }
570
571 ifc.ifc_len = sizeof(ifs);
572 ifc.ifc_req = ifs;
573 if (ioctl(SockFD, SIOCGIFCONF, &ifc) < 0)
574 {
575 close(SockFD);
576 return JIM_ERR;
577 }
578
579 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
580 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
581 {
582 //if (ifr->ifr_addr.sa_family == AF_INET)
583 {
584 if (strcmp("eth0", ifr->ifr_name) != 0)
585 continue;
586 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
587 if (ioctl(SockFD, SIOCGIFHWADDR, &ifreq) < 0)
588 {
589 close(SockFD);
590 return JIM_ERR;
591 }
592
593 close(SockFD);
594
595
596 Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0);
597
598 char buffer[256];
599 sprintf(buffer, "%02x-%02x-%02x-%02x-%02x-%02x",
600 ifreq.ifr_hwaddr.sa_data[0]&0xff,
601 ifreq.ifr_hwaddr.sa_data[1]&0xff,
602 ifreq.ifr_hwaddr.sa_data[2]&0xff,
603 ifreq.ifr_hwaddr.sa_data[3]&0xff,
604 ifreq.ifr_hwaddr.sa_data[4]&0xff,
605 ifreq.ifr_hwaddr.sa_data[5]&0xff);
606
607 Jim_AppendString(interp, tclOutput, buffer, strlen(buffer));
608
609 Jim_SetResult(interp, tclOutput);
610
611 return JIM_OK;
612 }
613 }
614 close(SockFD);
615
616 return JIM_ERR;
617
618 }
619
620 static const struct command_registration ioutil_command_handlers[] = {
621 {
622 .name = "cat",
623 .handler = handle_cat_command,
624 .mode = COMMAND_ANY,
625 .help = "display text file content",
626 .usage= "file_name",
627 },
628 {
629 .name = "trunc",
630 .handler = handle_trunc_command,
631 .mode = COMMAND_ANY,
632 .help = "truncate a file to zero length",
633 .usage= "file_name",
634 },
635 {
636 .name = "cp",
637 .handler = handle_cp_command,
638 .mode = COMMAND_ANY,
639 .help = "copy a file",
640 .usage = "src_file_name dst_file_name",
641 },
642 {
643 .name = "append_file",
644 .handler = handle_append_command,
645 .mode = COMMAND_ANY,
646 .help = "append a variable number of strings to a file",
647 .usage= "file_name [string ...]",
648 },
649 {
650 .name = "meminfo",
651 .handler = handle_meminfo_command,
652 .mode = COMMAND_ANY,
653 .help = "display free heap space",
654 },
655 {
656 .name = "rm",
657 .mode = COMMAND_ANY,
658 .handler = handle_rm_command,
659 .help = "remove a directory or file",
660 .usage = "file_name",
661 },
662
663 /*
664 * Peek and poke are security holes -- they manipulate
665 * server-internal addresses.
666 */
667
668 // jim handlers
669 {
670 .name = "peek",
671 .mode = COMMAND_ANY,
672 .jim_handler = ioutil_Jim_Command_peek,
673 .help = "peek at a memory address",
674 .usage = "address",
675 },
676 {
677 .name = "poke",
678 .mode = COMMAND_ANY,
679 .jim_handler = ioutil_Jim_Command_poke,
680 .help = "poke at a memory address",
681 .usage = "address value",
682 },
683 {
684 .name = "ls",
685 .mode = COMMAND_ANY,
686 .jim_handler = ioutil_Jim_Command_ls,
687 .help = "show a listing of files",
688 .usage = "dirname",
689 },
690 {
691 .name = "mac",
692 .mode = COMMAND_ANY,
693 .jim_handler = ioutil_Jim_Command_mac,
694 .help = "show MAC address",
695 },
696 {
697 .name = "ip",
698 .jim_handler = ioutil_Jim_Command_ip,
699 .mode = COMMAND_ANY,
700 .help = "show IP address",
701 },
702 COMMAND_REGISTRATION_DONE
703 };
704
705 int ioutil_init(struct command_context *cmd_ctx)
706 {
707 return register_commands(cmd_ctx, NULL, ioutil_command_handlers);
708 }

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)