hivex: Fix for endianess bug.
[hivex.git] / xml / hivexml.c
1 /* hivexml - Convert Windows Registry "hive" to XML file.
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 <unistd.h>
27 #include <errno.h>
28
29 #include <libxml/xmlwriter.h>
30
31 #include "hivex.h"
32
33 #ifdef HAVE_GETTEXT
34 #include "gettext.h"
35 #define _(str) dgettext(PACKAGE, (str))
36 //#define N_(str) dgettext(PACKAGE, (str))
37 #else
38 #define _(str) str
39 //#define N_(str) str
40 #endif
41
42 /* Callback functions. */
43 static int node_start (hive_h *, void *, hive_node_h, const char *name);
44 static int node_end (hive_h *, void *, hive_node_h, const char *name);
45 static int value_string (hive_h *, void *, hive_node_h, hive_value_h, hive_type t, size_t len, const char *key, const char *str);
46 static int value_multiple_strings (hive_h *, void *, hive_node_h, hive_value_h, hive_type t, size_t len, const char *key, char **argv);
47 static int value_string_invalid_utf16 (hive_h *, void *, hive_node_h, hive_value_h, hive_type t, size_t len, const char *key, const char *str);
48 static int value_dword (hive_h *, void *, hive_node_h, hive_value_h, hive_type t, size_t len, const char *key, int32_t);
49 static int value_qword (hive_h *, void *, hive_node_h, hive_value_h, hive_type t, size_t len, const char *key, int64_t);
50 static int value_binary (hive_h *, void *, hive_node_h, hive_value_h, hive_type t, size_t len, const char *key, const char *value);
51 static int value_none (hive_h *, void *, hive_node_h, hive_value_h, hive_type t, size_t len, const char *key, const char *value);
52 static int value_other (hive_h *, void *, hive_node_h, hive_value_h, hive_type t, size_t len, const char *key, const char *value);
53
54 static struct hivex_visitor visitor = {
55   .node_start = node_start,
56   .node_end = node_end,
57   .value_string = value_string,
58   .value_multiple_strings = value_multiple_strings,
59   .value_string_invalid_utf16 = value_string_invalid_utf16,
60   .value_dword = value_dword,
61   .value_qword = value_qword,
62   .value_binary = value_binary,
63   .value_none = value_none,
64   .value_other = value_other
65 };
66
67 #define XML_CHECK(proc, args)                                           \
68   do {                                                                  \
69     if ((proc args) == -1) {                                            \
70       fprintf (stderr, _("%s: failed to write XML document\n"), #proc); \
71       exit (EXIT_FAILURE);                                              \
72     }                                                                   \
73   } while (0)
74
75 int
76 main (int argc, char *argv[])
77 {
78   setlocale (LC_ALL, "");
79   bindtextdomain (PACKAGE, LOCALEBASEDIR);
80   textdomain (PACKAGE);
81
82   int c;
83   int open_flags = 0;
84   int visit_flags = 0;
85
86   while ((c = getopt (argc, argv, "dk")) != EOF) {
87     switch (c) {
88     case 'd':
89       open_flags |= HIVEX_OPEN_DEBUG;
90       break;
91     case 'k':
92       visit_flags |= HIVEX_VISIT_SKIP_BAD;
93       break;
94     default:
95       fprintf (stderr, "hivexml [-dk] regfile > output.xml\n");
96       exit (EXIT_FAILURE);
97     }
98   }
99
100   if (optind + 1 != argc) {
101     fprintf (stderr, _("hivexml: missing name of input file\n"));
102     exit (EXIT_FAILURE);
103   }
104
105   hive_h *h = hivex_open (argv[optind], open_flags);
106   if (h == NULL) {
107     perror (argv[optind]);
108     exit (EXIT_FAILURE);
109   }
110
111   /* Note both this macro, and xmlTextWriterStartDocument leak memory.  There
112    * doesn't seem to be any way to recover that memory, but it's not a
113    * large amount.
114    */
115   LIBXML_TEST_VERSION;
116
117   xmlTextWriterPtr writer;
118   writer = xmlNewTextWriterFilename ("/dev/stdout", 0);
119   if (writer == NULL) {
120     fprintf (stderr, _("xmlNewTextWriterFilename: failed to create XML writer\n"));
121     exit (EXIT_FAILURE);
122   }
123
124   XML_CHECK (xmlTextWriterStartDocument, (writer, NULL, "utf-8", NULL));
125   XML_CHECK (xmlTextWriterStartElement, (writer, BAD_CAST "hive"));
126
127   if (hivex_visit (h, &visitor, sizeof visitor, writer, visit_flags) == -1) {
128     perror (argv[optind]);
129     exit (EXIT_FAILURE);
130   }
131
132   if (hivex_close (h) == -1) {
133     perror (argv[optind]);
134     exit (EXIT_FAILURE);
135   }
136
137   XML_CHECK (xmlTextWriterEndElement, (writer));
138   XML_CHECK (xmlTextWriterEndDocument, (writer));
139   xmlFreeTextWriter (writer);
140
141   exit (EXIT_SUCCESS);
142 }
143
144 static int
145 node_start (hive_h *h, void *writer_v, hive_node_h node, const char *name)
146 {
147   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
148   XML_CHECK (xmlTextWriterStartElement, (writer, BAD_CAST "node"));
149   XML_CHECK (xmlTextWriterWriteAttribute, (writer, BAD_CAST "name", BAD_CAST name));
150   return 0;
151 }
152
153 static int
154 node_end (hive_h *h, void *writer_v, hive_node_h node, const char *name)
155 {
156   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
157   XML_CHECK (xmlTextWriterEndElement, (writer));
158   return 0;
159 }
160
161 static void
162 start_value (xmlTextWriterPtr writer,
163              const char *key, const char *type, const char *encoding)
164 {
165   XML_CHECK (xmlTextWriterStartElement, (writer, BAD_CAST "value"));
166   XML_CHECK (xmlTextWriterWriteAttribute, (writer, BAD_CAST "type", BAD_CAST type));
167   if (encoding)
168     XML_CHECK (xmlTextWriterWriteAttribute, (writer, BAD_CAST "encoding", BAD_CAST encoding));
169   if (*key)
170     XML_CHECK (xmlTextWriterWriteAttribute, (writer, BAD_CAST "key", BAD_CAST key));
171   else                          /* default key */
172     XML_CHECK (xmlTextWriterWriteAttribute, (writer, BAD_CAST "default", BAD_CAST "1"));
173 }
174
175 static void
176 end_value (xmlTextWriterPtr writer)
177 {
178   XML_CHECK (xmlTextWriterEndElement, (writer));
179 }
180
181 static int
182 value_string (hive_h *h, void *writer_v, hive_node_h node, hive_value_h value,
183               hive_type t, size_t len, const char *key, const char *str)
184 {
185   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
186   const char *type;
187
188   switch (t) {
189   case hive_t_string: type = "string"; break;
190   case hive_t_expand_string: type = "expand"; break;
191   case hive_t_link: type = "link"; break;
192
193   case hive_t_none:
194   case hive_t_binary:
195   case hive_t_dword:
196   case hive_t_dword_be:
197   case hive_t_multiple_strings:
198   case hive_t_resource_list:
199   case hive_t_full_resource_description:
200   case hive_t_resource_requirements_list:
201   case hive_t_qword:
202     abort ();                   /* internal error - should not happen */
203
204   default:
205     type = "unknown";
206   }
207
208   start_value (writer, key, type, NULL);
209   XML_CHECK (xmlTextWriterWriteString, (writer, BAD_CAST str));
210   end_value (writer);
211   return 0;
212 }
213
214 static int
215 value_multiple_strings (hive_h *h, void *writer_v, hive_node_h node,
216                         hive_value_h value, hive_type t, size_t len,
217                         const char *key, char **argv)
218 {
219   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
220   start_value (writer, key, "string-list", NULL);
221
222   size_t i;
223   for (i = 0; argv[i] != NULL; ++i) {
224     XML_CHECK (xmlTextWriterStartElement, (writer, BAD_CAST "string"));
225     XML_CHECK (xmlTextWriterWriteString, (writer, BAD_CAST argv[i]));
226     XML_CHECK (xmlTextWriterEndElement, (writer));
227   }
228
229   end_value (writer);
230   return 0;
231 }
232
233 static int
234 value_string_invalid_utf16 (hive_h *h, void *writer_v, hive_node_h node,
235                             hive_value_h value, hive_type t, size_t len,
236                             const char *key,
237                             const char *str /* original data */)
238 {
239   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
240   const char *type;
241
242   switch (t) {
243   case hive_t_string: type = "bad-string"; break;
244   case hive_t_expand_string: type = "bad-expand"; break;
245   case hive_t_link: type = "bad-link"; break;
246   case hive_t_multiple_strings: type = "bad-string-list"; break;
247
248   case hive_t_none:
249   case hive_t_binary:
250   case hive_t_dword:
251   case hive_t_dword_be:
252   case hive_t_resource_list:
253   case hive_t_full_resource_description:
254   case hive_t_resource_requirements_list:
255   case hive_t_qword:
256     abort ();                   /* internal error - should not happen */
257
258   default:
259     type = "unknown";
260   }
261
262   start_value (writer, key, type, "base64");
263   XML_CHECK (xmlTextWriterWriteBase64, (writer, str, 0, len));
264   end_value (writer);
265
266   return 0;
267 }
268
269 static int
270 value_dword (hive_h *h, void *writer_v, hive_node_h node, hive_value_h value,
271              hive_type t, size_t len, const char *key, int32_t v)
272 {
273   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
274   start_value (writer, key, "int32", NULL);
275   XML_CHECK (xmlTextWriterWriteFormatString, (writer, "%" PRIi32, v));
276   end_value (writer);
277   return 0;
278 }
279
280 static int
281 value_qword (hive_h *h, void *writer_v, hive_node_h node, hive_value_h value,
282              hive_type t, size_t len, const char *key, int64_t v)
283 {
284   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
285   start_value (writer, key, "int64", NULL);
286   XML_CHECK (xmlTextWriterWriteFormatString, (writer, "%" PRIi64, v));
287   end_value (writer);
288   return 0;
289 }
290
291 static int
292 value_binary (hive_h *h, void *writer_v, hive_node_h node, hive_value_h value,
293               hive_type t, size_t len, const char *key, const char *v)
294 {
295   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
296   start_value (writer, key, "binary", "base64");
297   XML_CHECK (xmlTextWriterWriteBase64, (writer, v, 0, len));
298   end_value (writer);
299   return 0;
300 }
301
302 static int
303 value_none (hive_h *h, void *writer_v, hive_node_h node, hive_value_h value,
304             hive_type t, size_t len, const char *key, const char *v)
305 {
306   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
307   start_value (writer, key, "none", "base64");
308   if (len > 0) XML_CHECK (xmlTextWriterWriteBase64, (writer, v, 0, len));
309   end_value (writer);
310   return 0;
311 }
312
313 static int
314 value_other (hive_h *h, void *writer_v, hive_node_h node, hive_value_h value,
315              hive_type t, size_t len, const char *key, const char *v)
316 {
317   xmlTextWriterPtr writer = (xmlTextWriterPtr) writer_v;
318   const char *type;
319
320   switch (t) {
321   case hive_t_none:
322   case hive_t_binary:
323   case hive_t_dword:
324   case hive_t_dword_be:
325   case hive_t_qword:
326   case hive_t_string:
327   case hive_t_expand_string:
328   case hive_t_link:
329   case hive_t_multiple_strings:
330     abort ();                   /* internal error - should not happen */
331
332   case hive_t_resource_list: type = "resource-list"; break;
333   case hive_t_full_resource_description: type = "resource-description"; break;
334   case hive_t_resource_requirements_list: type = "resource-requirements"; break;
335
336   default:
337     type = "unknown";
338   }
339
340   start_value (writer, key, type, "base64");
341   if (len > 0) XML_CHECK (xmlTextWriterWriteBase64, (writer, v, 0, len));
342   end_value (writer);
343
344   return 0;
345 }