hivex: example6: Hypothetical addition of keys for viostor.
[libguestfs.git] / 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_expand_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 }