hivex/hivexsh.c

   1 /* hivexsh - Hive shell.
   2  * Copyright (C) 2009 Red Hat Inc.
   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 along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 #include <config.h>
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdint.h>
  25 #include <inttypes.h>
  26 #include <fcntl.h>
  27 #include <unistd.h>
  28 #include <assert.h>
  29 #include <errno.h>
  30
  31 #ifdef HAVE_LIBREADLINE
  32 #include <readline/readline.h>
  33 #include <readline/history.h>
  34 #endif
  35
  36 #ifdef HAVE_GETTEXT
  37 #include "gettext.h"
  38 #define _(str) dgettext(PACKAGE, (str))
  39 //#define N_(str) dgettext(PACKAGE, (str))
  40 #else
  41 #define _(str) str
  42 //#define N_(str) str
  43 #endif
  44
  45 #define STREQ(a,b) (strcmp((a),(b)) == 0)
  46 #define STRCASEEQ(a,b) (strcasecmp((a),(b)) == 0)
  47 #define STRNEQ(a,b) (strcmp((a),(b)) != 0)
  48 //#define STRCASENEQ(a,b) (strcasecmp((a),(b)) != 0)
  49 //#define STREQLEN(a,b,n) (strncmp((a),(b),(n)) == 0)
  50 //#define STRCASEEQLEN(a,b,n) (strncasecmp((a),(b),(n)) == 0)
  51 //#define STRNEQLEN(a,b,n) (strncmp((a),(b),(n)) != 0)
  52 //#define STRCASENEQLEN(a,b,n) (strncasecmp((a),(b),(n)) != 0)
  53 #define STRPREFIX(a,b) (strncmp((a),(b),strlen((b))) == 0)
  54
  55 #include "c-ctype.h"
  56 #include "xstrtol.h"
  57
  58 #include "hivex.h"
  59 #include "byte_conversions.h"
  60
  61 #define HIVEX_MAX_VALUES         1000
  62
  63 static int quit = 0;
  64 static int is_tty;
  65 static hive_h *h = NULL;
  66 static char *prompt_string = NULL; /* Normal prompt string. */
  67 static char *loaded = NULL;     /* Basename of loaded file, if any. */
  68 static hive_node_h cwd;         /* Current node. */
  69 static int open_flags = 0;      /* Flags used when loading a hive file. */
  70
  71 static void usage (void) __attribute__((noreturn));
  72 static void print_node_path (hive_node_h, FILE *);
  73 static void set_prompt_string (void);
  74 static void initialize_readline (void);
  75 static void cleanup_readline (void);
  76 static void add_history_line (const char *);
  77 static char *rl_gets (const char *prompt_string);
  78 static void sort_strings (char **strings, int len);
  79 static int get_xdigit (char c);
  80 static int dispatch (char *cmd, char *args);
  81 static int cmd_add (char *name);
  82 static int cmd_cd (char *path);
  83 static int cmd_close (char *path);
  84 static int cmd_commit (char *path);
  85 static int cmd_del (char *args);
  86 static int cmd_help (char *args);
  87 static int cmd_load (char *hivefile);
  88 static int cmd_ls (char *args);
  89 static int cmd_lsval (char *args);
  90 static int cmd_setval (char *args);
  91
  92 static void
  93 usage (void)
  94 {
  95   fprintf (stderr, "hivexsh [-dfw] [hivefile]\n");
  96   exit (EXIT_FAILURE);
  97 }
  98
  99 int
 100 main (int argc, char *argv[])
 101 {
 102   setlocale (LC_ALL, "");
 103   bindtextdomain (PACKAGE, LOCALEBASEDIR);
 104   textdomain (PACKAGE);
 105
 106   int c;
 107   const char *filename = NULL;
 108
 109   set_prompt_string ();
 110
 111   while ((c = getopt (argc, argv, "dfw")) != EOF) {
 112     switch (c) {
 113     case 'd':
 114       open_flags |= HIVEX_OPEN_DEBUG;
 115       break;
 116     case 'f':
 117       filename = optarg;
 118       break;
 119     case 'w':
 120       open_flags |= HIVEX_OPEN_WRITE;
 121       break;
 122     default:
 123       usage ();
 124     }
 125   }
 126
 127   if (optind < argc) {
 128     if (optind + 1 != argc)
 129       usage ();
 130     if (cmd_load (argv[optind]) == -1)
 131       exit (EXIT_FAILURE);
 132   }
 133
 134   /* -f filename parameter */
 135   if (filename) {
 136     close (0);
 137     if (open (filename, O_RDONLY) == -1) {
 138       perror (filename);
 139       exit (EXIT_FAILURE);
 140     }
 141   }
 142
 143   /* Main loop. */
 144   is_tty = isatty (0);
 145   initialize_readline ();
 146
 147   if (is_tty)
 148     printf (_(
 149 "\n"
 150 "Welcome to hivexsh, the hivex interactive shell for examining\n"
 151 "Windows Registry binary hive files.\n"
 152 "\n"
 153 "Type: 'help' for help summary\n"
 154 "      'quit' to quit the shell\n"
 155 "\n"));
 156
 157   while (!quit) {
 158     char *buf = rl_gets (prompt_string);
 159     if (!buf) {
 160       quit = 1;
 161       if (is_tty)
 162         printf ("\n");
 163       break;
 164     }
 165
 166     while (*buf && c_isspace (*buf))
 167       buf++;
 168
 169     /* Ignore blank line. */
 170     if (!*buf) continue;
 171
 172     /* If the next character is '#' then this is a comment. */
 173     if (*buf == '#') continue;
 174
 175     /* Parsing is very simple - much simpler than guestfish.  This is
 176      * because Registry keys often contain spaces, and we don't want
 177      * to bother with quoting.  Therefore here we just split at the
 178      * first whitespace into "cmd<whitespace>arg(s)".  We let the
 179      * command decide how to deal with arg(s), if at all.
 180      */
 181     size_t len = strcspn (buf, " \t");
 182
 183     if (len == 0) continue;
 184
 185     char *cmd = buf;
 186     char *args;
 187     size_t i = 0;
 188
 189     if (buf[len] == '\0') {
 190       /* This is mostly safe.  Although the cmd_* functions do sometimes
 191        * modify args, then shouldn't do so when args is "".
 192        */
 193       args = (char *) "";
 194       goto got_command;
 195     }
 196
 197     buf[len] = '\0';
 198     args = buf + len + 1 + strspn (&buf[len+1], " \t");
 199
 200     len = strlen (args);
 201     while (len > 0 && c_isspace (args[len-1])) {
 202       args[len-1] = '\0';
 203       len--;
 204     }
 205
 206   got_command:
 207     /*printf ("command: '%s'  args: '%s'\n", cmd, args)*/;
 208     int r = dispatch (cmd, args);
 209     if (!is_tty && r == -1)
 210       exit (EXIT_FAILURE);
 211   }
 212
 213   cleanup_readline ();
 214   free (prompt_string);
 215   free (loaded);
 216   if (h) hivex_close (h);
 217   exit (0);
 218 }
 219
 220 /* Set the prompt string.  This is called whenever it could change, eg.
 221  * after loading a file or changing directory.
 222  */
 223 static void
 224 set_prompt_string (void)
 225 {
 226   free (prompt_string);
 227   prompt_string = NULL;
 228
 229   FILE *fp;
 230   char *ptr;
 231   size_t size;
 232   fp = open_memstream (&ptr, &size);
 233   if (fp == NULL) {
 234     perror ("open_memstream");
 235     exit (EXIT_FAILURE);
 236   }
 237
 238   if (h) {
 239     assert (loaded != NULL);
 240     assert (cwd != 0);
 241
 242     fputs (loaded, fp);
 243     print_node_path (cwd, fp);
 244   }
 245
 246   fprintf (fp, "> ");
 247   fclose (fp);
 248   prompt_string = ptr;
 249 }
 250
 251 /* Print the \full\path of a node. */
 252 static void
 253 print_node_path (hive_node_h node, FILE *fp)
 254 {
 255   hive_node_h root = hivex_root (h);
 256
 257   if (node == root) {
 258     fputc ('\\', fp);
 259     return;
 260   }
 261
 262   hive_node_h parent = hivex_node_parent (h, node);
 263   if (parent == 0) {
 264     fprintf (stderr, _("hivexsh: error getting parent of node %zu\n"), node);
 265     return;
 266   }
 267   print_node_path (parent, fp);
 268
 269   if (parent != root)
 270     fputc ('\\', fp);
 271
 272   char *name = hivex_node_name (h, node);
 273   if (name == NULL) {
 274     fprintf (stderr, _("hivexsh: error getting node name of node %zx\n"), node);
 275     return;
 276   }
 277
 278   fputs (name, fp);
 279   free (name);
 280 }
 281
 282 static char *line_read = NULL;
 283
 284 static char *
 285 rl_gets (const char *prompt_string)
 286 {
 287 #ifdef HAVE_LIBREADLINE
 288
 289   if (is_tty) {
 290     if (line_read) {
 291       free (line_read);
 292       line_read = NULL;
 293     }
 294
 295     line_read = readline (prompt_string);
 296
 297     if (line_read && *line_read)
 298       add_history_line (line_read);
 299
 300     return line_read;
 301   }
 302
 303 #endif /* HAVE_LIBREADLINE */
 304
 305   static char buf[8192];
 306   int len;
 307
 308   if (is_tty)
 309     printf ("%s", prompt_string);
 310   line_read = fgets (buf, sizeof buf, stdin);
 311
 312   if (line_read) {
 313     len = strlen (line_read);
 314     if (len > 0 && buf[len-1] == '\n') buf[len-1] = '\0';
 315   }
 316
 317   return line_read;
 318 }
 319
 320 #ifdef HAVE_LIBREADLINE
 321 static char histfile[1024];
 322 static int nr_history_lines = 0;
 323 #endif
 324
 325 static void
 326 initialize_readline (void)
 327 {
 328 #ifdef HAVE_LIBREADLINE
 329   const char *home;
 330
 331   home = getenv ("HOME");
 332   if (home) {
 333     snprintf (histfile, sizeof histfile, "%s/.hivexsh", home);
 334     using_history ();
 335     (void) read_history (histfile);
 336   }
 337
 338   rl_readline_name = "hivexsh";
 339 #endif
 340 }
 341
 342 static void
 343 cleanup_readline (void)
 344 {
 345 #ifdef HAVE_LIBREADLINE
 346   int fd;
 347
 348   if (histfile[0] != '\0') {
 349     fd = open (histfile, O_WRONLY|O_CREAT, 0644);
 350     if (fd == -1) {
 351       perror (histfile);
 352       return;
 353     }
 354     close (fd);
 355
 356     (void) append_history (nr_history_lines, histfile);
 357   }
 358 #endif
 359 }
 360
 361 static void
 362 add_history_line (const char *line)
 363 {
 364 #ifdef HAVE_LIBREADLINE
 365   add_history (line);
 366   nr_history_lines++;
 367 #endif
 368 }
 369
 370 static int
 371 compare (const void *vp1, const void *vp2)
 372 {
 373   char * const *p1 = (char * const *) vp1;
 374   char * const *p2 = (char * const *) vp2;
 375   return strcasecmp (*p1, *p2);
 376 }
 377
 378 static void
 379 sort_strings (char **strings, int len)
 380 {
 381   qsort (strings, len, sizeof (char *), compare);
 382 }
 383
 384 static int
 385 get_xdigit (char c)
 386 {
 387   switch (c) {
 388   case '0'...'9': return c - '0';
 389   case 'a'...'f': return c - 'a' + 10;
 390   case 'A'...'F': return c - 'A' + 10;
 391   default: return -1;
 392   }
 393 }
 394
 395 static int
 396 dispatch (char *cmd, char *args)
 397 {
 398   if (STRCASEEQ (cmd, "help"))
 399     return cmd_help (args);
 400   else if (STRCASEEQ (cmd, "load"))
 401     return cmd_load (args);
 402   else if (STRCASEEQ (cmd, "exit") ||
 403            STRCASEEQ (cmd, "q") ||
 404            STRCASEEQ (cmd, "quit")) {
 405     quit = 1;
 406     return 0;
 407   }
 408
 409   /* If no hive file is loaded (!h) then only the small selection of
 410    * commands above will work.
 411    */
 412   if (!h) {
 413     fprintf (stderr, _("hivexsh: you must load a hive file first using 'load hivefile'\n"));
 414     return -1;
 415   }
 416
 417   if (STRCASEEQ (cmd, "add"))
 418     return cmd_add (args);
 419   else if (STRCASEEQ (cmd, "cd"))
 420     return cmd_cd (args);
 421   else if (STRCASEEQ (cmd, "close") || STRCASEEQ (cmd, "unload"))
 422     return cmd_close (args);
 423   else if (STRCASEEQ (cmd, "commit"))
 424     return cmd_commit (args);
 425   else if (STRCASEEQ (cmd, "del"))
 426     return cmd_del (args);
 427   else if (STRCASEEQ (cmd, "ls"))
 428     return cmd_ls (args);
 429   else if (STRCASEEQ (cmd, "lsval"))
 430     return cmd_lsval (args);
 431   else if (STRCASEEQ (cmd, "setval"))
 432     return cmd_setval (args);
 433   else {
 434     fprintf (stderr, _("hivexsh: unknown command '%s', use 'help' for help summary\n"),
 435              cmd);
 436     return -1;
 437   }
 438 }
 439
 440 static int
 441 cmd_load (char *hivefile)
 442 {
 443   if (STREQ (hivefile, "")) {
 444     fprintf (stderr, _("hivexsh: load: no hive file name given to load\n"));
 445     return -1;
 446   }
 447
 448   if (h) hivex_close (h);
 449   h = NULL;
 450
 451   free (loaded);
 452   loaded = NULL;
 453
 454   cwd = 0;
 455
 456   h = hivex_open (hivefile, open_flags);
 457   if (h == NULL) {
 458     fprintf (stderr,
 459              _(
 460 "hivexsh: failed to open hive file: %s: %m\n"
 461 "\n"
 462 "If you think this file is a valid Windows binary hive file (_not_\n"
 463 "a regedit *.reg file) then please run this command again using the\n"
 464 "hivexsh option '-d' and attach the complete output _and_ the hive file\n"
 465 "which fails into a bug report at https://bugzilla.redhat.com/\n"
 466 "\n"),
 467              hivefile);
 468     return -1;
 469   }
 470
 471   /* Get the basename of the file for the prompt. */
 472   char *p = strrchr (hivefile, '/');
 473   if (p)
 474     loaded = strdup (p+1);
 475   else
 476     loaded = strdup (hivefile);
 477   if (!loaded) {
 478     perror ("strdup");
 479     exit (EXIT_FAILURE);
 480   }
 481
 482   cwd = hivex_root (h);
 483
 484   set_prompt_string ();
 485
 486   return 0;
 487 }
 488
 489 static int
 490 cmd_close (char *args)
 491 {
 492   if (STRNEQ (args, "")) {
 493     fprintf (stderr, _("hivexsh: '%s' command should not be given arguments\n"),
 494              "close");
 495     return -1;
 496   }
 497
 498   if (h) hivex_close (h);
 499   h = NULL;
 500
 501   free (loaded);
 502   loaded = NULL;
 503
 504   cwd = 0;
 505
 506   set_prompt_string ();
 507
 508   return 0;
 509 }
 510
 511 static int
 512 cmd_commit (char *path)
 513 {
 514   if (STREQ (path, ""))
 515     path = NULL;
 516
 517   if (hivex_commit (h, path, 0) == -1) {
 518     perror ("hivexsh: commit");
 519     return -1;
 520   }
 521
 522   return 0;
 523 }
 524
 525 static int
 526 cmd_cd (char *path)
 527 {
 528   if (STREQ (path, "")) {
 529     print_node_path (cwd, stdout);
 530     fputc ('\n', stdout);
 531     return 0;
 532   }
 533
 534   if (path[0] == '\\' && path[1] == '\\') {
 535     fprintf (stderr, _("%s: %s: \\ characters in path are doubled - are you escaping the path parameter correctly?\n"), "hivexsh", path);
 536     return -1;
 537   }
 538
 539   hive_node_h new_cwd = cwd;
 540   hive_node_h root = hivex_root (h);
 541
 542   if (path[0] == '\\') {
 543     new_cwd = root;
 544     path++;
 545   }
 546
 547   while (path[0]) {
 548     size_t len = strcspn (path, "\\");
 549     if (len == 0) {
 550       path++;
 551       continue;
 552     }
 553
 554     char *elem = path;
 555     path = path[len] == '\0' ? &path[len] : &path[len+1];
 556     elem[len] = '\0';
 557
 558     if (len == 1 && STREQ (elem, "."))
 559       continue;
 560
 561     if (len == 2 && STREQ (elem, "..")) {
 562       if (new_cwd != root)
 563         new_cwd = hivex_node_parent (h, new_cwd);
 564       continue;
 565     }
 566
 567     errno = 0;
 568     new_cwd = hivex_node_get_child (h, new_cwd, elem);
 569     if (new_cwd == 0) {
 570       if (errno)
 571         perror ("hivexsh: cd");
 572       else
 573         fprintf (stderr, _("hivexsh: cd: subkey '%s' not found\n"),
 574                  elem);
 575       return -1;
 576     }
 577   }
 578
 579   if (new_cwd != cwd) {
 580     cwd = new_cwd;
 581     set_prompt_string ();
 582   }
 583
 584   return 0;
 585 }
 586
 587 static int
 588 cmd_help (char *args)
 589 {
 590   printf (_(
 591 "Navigate through the hive's keys using the 'cd' command, as if it\n"
 592 "contained a filesystem, and use 'ls' to list the subkeys of the\n"
 593 "current key.  Full documentation is in the hivexsh(1) manual page.\n"));
 594
 595   return 0;
 596 }
 597
 598 static int
 599 cmd_ls (char *args)
 600 {
 601   if (STRNEQ (args, "")) {
 602     fprintf (stderr, _("hivexsh: '%s' command should not be given arguments\n"),
 603              "ls");
 604     return -1;
 605   }
 606
 607   /* Get the subkeys. */
 608   hive_node_h *children = hivex_node_children (h, cwd);
 609   if (children == NULL) {
 610     perror ("ls");
 611     return -1;
 612   }
 613
 614   /* Get names for each subkey. */
 615   size_t len;
 616   for (len = 0; children[len] != 0; ++len)
 617     ;
 618
 619   char **names = calloc (len, sizeof (char *));
 620   if (names == NULL) {
 621     perror ("malloc");
 622     exit (EXIT_FAILURE);
 623   }
 624
 625   int ret = -1;
 626   size_t i;
 627   for (i = 0; i < len; ++i) {
 628     names[i] = hivex_node_name (h, children[i]);
 629     if (names[i] == NULL) {
 630       perror ("hivex_node_name");
 631       goto error;
 632     }
 633   }
 634
 635   /* Sort the names. */
 636   sort_strings (names, len);
 637
 638   for (i = 0; i < len; ++i)
 639     printf ("%s\n", names[i]);
 640
 641   ret = 0;
 642  error:
 643   free (children);
 644   for (i = 0; i < len; ++i)
 645     free (names[i]);
 646   free (names);
 647   return ret;
 648 }
 649
 650 static int
 651 cmd_lsval (char *key)
 652 {
 653   if (STRNEQ (key, "")) {
 654     hive_value_h value;
 655
 656     errno = 0;
 657     if (STREQ (key, "@"))       /* default key written as "@" */
 658       value = hivex_node_get_value (h, cwd, "");
 659     else
 660       value = hivex_node_get_value (h, cwd, key);
 661
 662     if (value == 0) {
 663       if (errno)
 664         goto error;
 665       /* else key not found */
 666       fprintf (stderr, _("%s: %s: key not found\n"), "hivexsh", key);
 667       return -1;
 668     }
 669
 670     /* Print the value. */
 671     hive_type t;
 672     size_t len;
 673     if (hivex_value_type (h, value, &t, &len) == -1)
 674       goto error;
 675
 676     switch (t) {
 677     case hive_t_string:
 678     case hive_t_expand_string:
 679     case hive_t_link: {
 680       char *str = hivex_value_string (h, value);
 681       if (!str)
 682         goto error;
 683
 684       puts (str); /* note: this adds a single \n character */
 685       free (str);
 686       break;
 687     }
 688
 689     case hive_t_dword:
 690     case hive_t_dword_be: {
 691       int32_t j = hivex_value_dword (h, value);
 692       printf ("%" PRIi32 "\n", j);
 693       break;
 694     }
 695
 696     case hive_t_qword: {
 697       int64_t j = hivex_value_qword (h, value);
 698       printf ("%" PRIi64 "\n", j);
 699       break;
 700     }
 701
 702     case hive_t_multiple_strings: {
 703       char **strs = hivex_value_multiple_strings (h, value);
 704       if (!strs)
 705         goto error;
 706       size_t j;
 707       for (j = 0; strs[j] != NULL; ++j) {
 708         puts (strs[j]);
 709         free (strs[j]);
 710       }
 711       free (strs);
 712       break;
 713     }
 714
 715     case hive_t_none:
 716     case hive_t_binary:
 717     case hive_t_resource_list:
 718     case hive_t_full_resource_description:
 719     case hive_t_resource_requirements_list:
 720     default: {
 721       char *data = hivex_value_value (h, value, &t, &len);
 722       if (!data)
 723         goto error;
 724
 725       if (fwrite (data, 1, len, stdout) != len)
 726         goto error;
 727
 728       free (data);
 729       break;
 730     }
 731     } /* switch */
 732   } else {
 733     /* No key specified, so print all keys in this node.  We do this
 734      * in a format which looks like the output of regedit, although
 735      * this isn't a particularly useful format.
 736      */
 737     hive_value_h *values;
 738
 739     values = hivex_node_values (h, cwd);
 740     if (values == NULL)
 741       goto error;
 742
 743     size_t i;
 744     for (i = 0; values[i] != 0; ++i) {
 745       char *key = hivex_value_key (h, values[i]);
 746       if (!key) goto error;
 747
 748       if (*key) {
 749         putchar ('"');
 750         size_t j;
 751         for (j = 0; key[j] != 0; ++j) {
 752           if (key[j] == '"' || key[j] == '\\')
 753             putchar ('\\');
 754           putchar (key[j]);
 755         }
 756         putchar ('"');
 757       } else
 758         printf ("\"@\"");       /* default key in regedit files */
 759       putchar ('=');
 760       free (key);
 761
 762       hive_type t;
 763       size_t len;
 764       if (hivex_value_type (h, values[i], &t, &len) == -1)
 765         goto error;
 766
 767       switch (t) {
 768       case hive_t_string:
 769       case hive_t_expand_string:
 770       case hive_t_link: {
 771         char *str = hivex_value_string (h, values[i]);
 772         if (!str)
 773           goto error;
 774
 775         if (t != hive_t_string)
 776           printf ("str(%d):", t);
 777         putchar ('"');
 778         size_t j;
 779         for (j = 0; str[j] != 0; ++j) {
 780           if (str[j] == '"' || str[j] == '\\')
 781             putchar ('\\');
 782           putchar (str[j]);
 783         }
 784         putchar ('"');
 785         free (str);
 786         break;
 787       }
 788
 789       case hive_t_dword:
 790       case hive_t_dword_be: {
 791         int32_t j = hivex_value_dword (h, values[i]);
 792         printf ("dword:%08" PRIx32, j);
 793         break;
 794       }
 795
 796       case hive_t_qword: /* sic */
 797       case hive_t_none:
 798       case hive_t_binary:
 799       case hive_t_multiple_strings:
 800       case hive_t_resource_list:
 801       case hive_t_full_resource_description:
 802       case hive_t_resource_requirements_list:
 803       default: {
 804         char *data = hivex_value_value (h, values[i], &t, &len);
 805         if (!data)
 806           goto error;
 807
 808         printf ("hex(%d):", t);
 809         size_t j;
 810         for (j = 0; j < len; ++j) {
 811           if (j > 0)
 812             putchar (',');
 813           printf ("%02x", data[j]);
 814         }
 815         break;
 816       }
 817       } /* switch */
 818
 819       putchar ('\n');
 820     } /* for */
 821
 822     free (values);
 823   }
 824
 825   return 0;
 826
 827  error:
 828   perror ("hivexsh: lsval");
 829   return -1;
 830 }
 831
 832 static int
 833 cmd_setval (char *nrvals_str)
 834 {
 835   strtol_error xerr;
 836
 837   /* Parse number of values. */
 838   long nrvals;
 839   xerr = xstrtol (nrvals_str, NULL, 0, &nrvals, "");
 840   if (xerr != LONGINT_OK) {
 841     fprintf (stderr, _("%s: %s: invalid integer parameter (%s returned %d)\n"),
 842              "setval", "nrvals", "xstrtol", xerr);
 843     return -1;
 844   }
 845   if (nrvals < 0 || nrvals > HIVEX_MAX_VALUES) {
 846     fprintf (stderr, _("%s: %s: integer out of range\n"),
 847              "setval", "nrvals");
 848     return -1;
 849   }
 850
 851   struct hive_set_value *values =
 852     calloc (nrvals, sizeof (struct hive_set_value));
 853   if (values == NULL) {
 854     perror ("calloc");
 855     exit (EXIT_FAILURE);
 856   }
 857
 858   int ret = -1;
 859
 860   /* Read nrvals * 2 lines of input, nrvals * (key, value) pairs, as
 861    * explained in the man page.
 862    */
 863   int i, j;
 864   for (i = 0; i < nrvals; ++i) {
 865     /* Read key. */
 866     char *buf = rl_gets ("  key> ");
 867     if (!buf) {
 868       fprintf (stderr, _("hivexsh: setval: unexpected end of input\n"));
 869       quit = 1;
 870       goto error;
 871     }
 872
 873     /* Note that buf will be overwritten by the next call to rl_gets. */
 874     if (STREQ (buf, "@"))
 875       values[i].key = strdup ("");
 876     else
 877       values[i].key = strdup (buf);
 878     if (values[i].key == NULL) {
 879       perror ("strdup");
 880       exit (EXIT_FAILURE);
 881     }
 882
 883     /* Read value. */
 884     buf = rl_gets ("value> ");
 885     if (!buf) {
 886       fprintf (stderr, _("hivexsh: setval: unexpected end of input\n"));
 887       quit = 1;
 888       goto error;
 889     }
 890
 891     if (STREQ (buf, "none")) {
 892       values[i].t = hive_t_none;
 893       values[i].len = 0;
 894     }
 895     else if (STRPREFIX (buf, "string:")) {
 896       buf += 7;
 897       values[i].t = hive_t_string;
 898       int nr_chars = strlen (buf);
 899       values[i].len = 2 * (nr_chars + 1);
 900       values[i].value = malloc (values[i].len);
 901       if (!values[i].value) {
 902         perror ("malloc");
 903         exit (EXIT_FAILURE);
 904       }
 905       for (j = 0; j <= /* sic */ nr_chars; ++j) {
 906         if (buf[j] & 0x80) {
 907           fprintf (stderr, _("hivexsh: string(utf16le): only 7 bit ASCII strings are supported for input\n"));
 908           goto error;
 909         }
 910         values[i].value[2*j] = buf[j];
 911         values[i].value[2*j+1] = '\0';
 912       }
 913     }
 914     else if (STRPREFIX (buf, "expandstring:")) {
 915       buf += 13;
 916       values[i].t = hive_t_string;
 917       int nr_chars = strlen (buf);
 918       values[i].len = 2 * (nr_chars + 1);
 919       values[i].value = malloc (values[i].len);
 920       if (!values[i].value) {
 921         perror ("malloc");
 922         exit (EXIT_FAILURE);
 923       }
 924       for (j = 0; j <= /* sic */ nr_chars; ++j) {
 925         if (buf[j] & 0x80) {
 926           fprintf (stderr, _("hivexsh: string(utf16le): only 7 bit ASCII strings are supported for input\n"));
 927           goto error;
 928         }
 929         values[i].value[2*j] = buf[j];
 930         values[i].value[2*j+1] = '\0';
 931       }
 932     }
 933     else if (STRPREFIX (buf, "dword:")) {
 934       buf += 6;
 935       values[i].t = hive_t_dword;
 936       values[i].len = 4;
 937       values[i].value = malloc (4);
 938       if (!values[i].value) {
 939         perror ("malloc");
 940         exit (EXIT_FAILURE);
 941       }
 942       long n;
 943       xerr = xstrtol (buf, NULL, 0, &n, "");
 944       if (xerr != LONGINT_OK) {
 945         fprintf (stderr, _("%s: %s: invalid integer parameter (%s returned %d)\n"),
 946                  "setval", "dword", "xstrtol", xerr);
 947         goto error;
 948       }
 949       if (n < 0 || n > UINT32_MAX) {
 950         fprintf (stderr, _("%s: %s: integer out of range\n"),
 951                  "setval", "dword");
 952         goto error;
 953       }
 954       uint32_t u32 = htole32 (n);
 955       memcpy (values[i].value, &u32, 4);
 956     }
 957     else if (STRPREFIX (buf, "qword:")) {
 958       buf += 6;
 959       values[i].t = hive_t_qword;
 960       values[i].len = 8;
 961       values[i].value = malloc (8);
 962       if (!values[i].value) {
 963         perror ("malloc");
 964         exit (EXIT_FAILURE);
 965       }
 966       long long n;
 967       xerr = xstrtoll (buf, NULL, 0, &n, "");
 968       if (xerr != LONGINT_OK) {
 969         fprintf (stderr, _("%s: %s: invalid integer parameter (%s returned %d)\n"),
 970                  "setval", "dword", "xstrtoll", xerr);
 971         goto error;
 972       }
 973 #if 0
 974       if (n < 0 || n > UINT64_MAX) {
 975         fprintf (stderr, _("%s: %s: integer out of range\n"),
 976                  "setval", "dword");
 977         goto error;
 978       }
 979 #endif
 980       uint64_t u64 = htole64 (n);
 981       memcpy (values[i].value, &u64, 4);
 982     }
 983     else if (STRPREFIX (buf, "hex:")) {
 984       /* Read the type. */
 985       buf += 4;
 986       size_t len = strcspn (buf, ":");
 987       char *nextbuf;
 988       if (buf[len] == '\0')     /* "hex:t" */
 989         nextbuf = &buf[len];
 990       else {                    /* "hex:t:..." */
 991         buf[len] = '\0';
 992         nextbuf = &buf[len+1];
 993       }
 994
 995       long t;
 996       xerr = xstrtol (buf, NULL, 0, &t, "");
 997       if (xerr != LONGINT_OK) {
 998         fprintf (stderr, _("%s: %s: invalid integer parameter (%s returned %d)\n"),
 999                  "setval", "hex", "xstrtol", xerr);
1000         goto error;
1001       }
1002       if (t < 0 || t > UINT32_MAX) {
1003         fprintf (stderr, _("%s: %s: integer out of range\n"),
1004                  "setval", "hex");
1005         goto error;
1006       }
1007       values[i].t = t;
1008
1009       /* Read the hex data. */
1010       buf = nextbuf;
1011
1012       /* The allocation length is an overestimate, but it doesn't matter. */
1013       values[i].value = malloc (1 + strlen (buf) / 2);
1014       if (!values[i].value) {
1015         perror ("malloc");
1016         exit (EXIT_FAILURE);
1017       }
1018       values[i].len = 0;
1019
1020       while (*buf) {
1021         int c = 0;
1022
1023         for (j = 0; *buf && j < 2; buf++) {
1024           if (c_isxdigit (*buf)) { /* NB: ignore non-hex digits. */
1025             c <<= 4;
1026             c |= get_xdigit (*buf);
1027             j++;
1028           }
1029         }
1030
1031         if (j == 2) values[i].value[values[i].len++] = c;
1032         else if (j == 1) {
1033           fprintf (stderr, _("hivexsh: setval: trailing garbage after hex string\n"));
1034           goto error;
1035         }
1036       }
1037     }
1038     else {
1039       fprintf (stderr,
1040                _("hivexsh: setval: cannot parse value string, please refer to the man page hivexsh(1) for help: %s\n"),
1041                buf);
1042       goto error;
1043     }
1044   }
1045
1046   ret = hivex_node_set_values (h, cwd, nrvals, values, 0);
1047
1048  error:
1049   /* Free values array. */
1050   for (i = 0; i < nrvals; ++i) {
1051     free (values[i].key);
1052     free (values[i].value);
1053   }
1054   free (values);
1055
1056   return ret;
1057 }
1058
1059 static int
1060 cmd_del (char *args)
1061 {
1062   if (STRNEQ (args, "")) {
1063     fprintf (stderr, _("hivexsh: '%s' command should not be given arguments\n"),
1064              "del");
1065     return -1;
1066   }
1067
1068   if (cwd == hivex_root (h)) {
1069     fprintf (stderr, _("hivexsh: del: the root node cannot be deleted\n"));
1070     return -1;
1071   }
1072
1073   hive_node_h new_cwd = hivex_node_parent (h, cwd);
1074
1075   if (hivex_node_delete_child (h, cwd) == -1) {
1076     perror ("hivexsh: del");
1077     return -1;
1078   }
1079
1080   cwd = new_cwd;
1081   set_prompt_string ();
1082   return 0;
1083 }
1084
1085 static int
1086 cmd_add (char *name)
1087 {
1088   hive_node_h node = hivex_node_add_child (h, cwd, name);
1089   if (node == 0) {
1090     perror ("hivexsh: add");
1091     return -1;
1092   }
1093   return 0;
1094 }