OpenWrt – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * A tool for reading the TFFS partitions (a name-value storage usually
3 * found in AVM Fritz!Box based devices).
4 *
5 * Copyright (c) 2015-2016 Martin Blumenstingl <martin.blumenstingl@googlemail.com>
6 *
7 * Based on the TFFS 2.0 kernel driver from AVM:
8 * Copyright (c) 2004-2007 AVM GmbH <fritzbox_info@avm.de>
9 * and the OpenWrt TFFS kernel driver:
10 * Copyright (c) 2013 John Crispin <blogic@openwrt.org>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License along
23 * with this program; if not, write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 */
26  
27 #include <stdbool.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <stdint.h>
31 #include <string.h>
32 #include <libgen.h>
33 #include <getopt.h>
34 #include <unistd.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <arpa/inet.h>
38  
39 #define TFFS_ID_END 0xffff
40 #define TFFS_ID_TABLE_NAME 0x01ff
41  
42 static char *progname;
43 static char *input_file;
44 static unsigned long tffs_size;
45 static char *name_filter = NULL;
46 static bool show_all = false;
47 static bool print_all_key_names = false;
48 static bool swap_bytes = false;
49  
50 struct tffs_entry_header {
51 uint16_t id;
52 uint16_t len;
53 };
54  
55 struct tffs_entry {
56 const struct tffs_entry_header *header;
57 char *name;
58 uint8_t *val;
59 };
60  
61 struct tffs_name_table_entry {
62 const uint32_t *id;
63 const char *val;
64 };
65  
66 struct tffs_key_name_table {
67 uint32_t size;
68 struct tffs_name_table_entry *entries;
69 };
70  
71 static inline uint16_t get_header_len(const struct tffs_entry_header *header)
72 {
73 if (swap_bytes)
74 return ntohs(header->len);
75  
76 return header->len;
77 }
78  
79 static inline uint16_t get_header_id(const struct tffs_entry_header *header)
80 {
81 if (swap_bytes)
82 return ntohs(header->id);
83  
84 return header->id;
85 }
86  
87 static inline uint16_t to_entry_header_id(uint32_t name_id)
88 {
89 if (swap_bytes)
90 return ntohl(name_id) & 0xffff;
91  
92 return name_id & 0xffff;
93 }
94  
95 static inline uint32_t get_walk_size(uint32_t entry_len)
96 {
97 return (entry_len + 3) & ~0x03;
98 }
99  
100 static void print_entry_value(const struct tffs_entry *entry)
101 {
102 int i;
103  
104 /* These are NOT NULL terminated. */
105 for (i = 0; i < get_header_len(entry->header); i++)
106 fprintf(stdout, "%c", entry->val[i]);
107 }
108  
109 static void parse_entry(uint8_t *buffer, uint32_t pos,
110 struct tffs_entry *entry)
111 {
112 entry->header = (struct tffs_entry_header *) &buffer[pos];
113 entry->val = &buffer[pos + sizeof(struct tffs_entry_header)];
114 }
115  
116 static int find_entry(uint8_t *buffer, uint16_t id, struct tffs_entry *entry)
117 {
118 uint32_t pos = 0;
119  
120 do {
121 parse_entry(buffer, pos, entry);
122  
123 if (get_header_id(entry->header) == id)
124 return 1;
125  
126 pos += sizeof(struct tffs_entry_header);
127 pos += get_walk_size(get_header_len(entry->header));
128 } while (pos < tffs_size && entry->header->id != TFFS_ID_END);
129  
130 return 0;
131 }
132  
133 static void parse_key_names(struct tffs_entry *names_entry,
134 struct tffs_key_name_table *key_names)
135 {
136 uint32_t pos = 0, i = 0;
137 struct tffs_name_table_entry *name_item;
138  
139 key_names->entries = calloc(sizeof(*name_item), 1);
140  
141 do {
142 name_item = &key_names->entries[i];
143  
144 name_item->id = (uint32_t *) &names_entry->val[pos];
145 pos += sizeof(*name_item->id);
146 name_item->val = (const char *) &names_entry->val[pos];
147  
148 /*
149 * There is no "length" field because the string values are
150 * simply NULL-terminated -> strlen() gives us the size.
151 */
152 pos += get_walk_size(strlen(name_item->val) + 1);
153  
154 ++i;
155 key_names->entries = realloc(key_names->entries,
156 sizeof(*name_item) * (i + 1));
157 } while (pos < get_header_len(names_entry->header));
158  
159 key_names->size = i;
160 }
161  
162 static void show_all_key_names(struct tffs_key_name_table *key_names)
163 {
164 int i;
165  
166 for (i = 0; i < key_names->size; i++)
167 printf("%s\n", key_names->entries[i].val);
168 }
169  
170 static int show_all_key_value_pairs(uint8_t *buffer,
171 struct tffs_key_name_table *key_names)
172 {
173 int i, has_value = 0;
174 uint16_t id;
175 struct tffs_entry tmp;
176  
177 for (i = 0; i < key_names->size; i++) {
178 id = to_entry_header_id(*key_names->entries[i].id);
179  
180 if (find_entry(buffer, id, &tmp)) {
181 printf("%s=", key_names->entries[i].val);
182 print_entry_value(&tmp);
183 printf("\n");
184 has_value++;
185 }
186 }
187  
188 if (!has_value) {
189 fprintf(stderr, "ERROR: no values found!\n");
190 return EXIT_FAILURE;
191 }
192  
193 return EXIT_SUCCESS;
194 }
195  
196 static int show_matching_key_value(uint8_t *buffer,
197 struct tffs_key_name_table *key_names)
198 {
199 int i;
200 uint16_t id;
201 struct tffs_entry tmp;
202 const char *name;
203  
204 for (i = 0; i < key_names->size; i++) {
205 name = key_names->entries[i].val;
206  
207 if (strncmp(name, name_filter, strlen(name)) == 0) {
208 id = to_entry_header_id(*key_names->entries[i].id);
209  
210 if (find_entry(buffer, id, &tmp)) {
211 print_entry_value(&tmp);
212 printf("\n");
213 return EXIT_SUCCESS;
214 } else {
215 fprintf(stderr,
216 "ERROR: no value found for name %s!\n",
217 name);
218 return EXIT_FAILURE;
219 }
220 }
221 }
222  
223 fprintf(stderr, "ERROR: Unknown key name %s!\n", name_filter);
224 return EXIT_FAILURE;
225 }
226  
227 static void usage(int status)
228 {
229 FILE *stream = (status != EXIT_SUCCESS) ? stderr : stdout;
230  
231 fprintf(stream, "Usage: %s [OPTIONS...]\n", progname);
232 fprintf(stream,
233 "\n"
234 "Options:\n"
235 " -a list all key value pairs found in the TFFS file/device\n"
236 " -b swap bytes while parsing the TFFS file/device\n"
237 " -h show this screen\n"
238 " -i <file> inspect the given TFFS file/device <file>\n"
239 " -l list all supported keys\n"
240 " -n <key name> display the value of the given key\n"
241 " -s <size> the (max) size of the TFFS file/device <size>\n"
242 );
243  
244 exit(status);
245 }
246  
247 static int file_exist(char *filename)
248 {
249 struct stat buffer;
250  
251 return stat(filename, &buffer) == 0;
252 }
253  
254 static void parse_options(int argc, char *argv[])
255 {
256 while (1)
257 {
258 int c;
259  
260 c = getopt(argc, argv, "abhi:ln:s:");
261 if (c == -1)
262 break;
263  
264 switch (c) {
265 case 'a':
266 show_all = true;
267 name_filter = NULL;
268 print_all_key_names = false;
269 break;
270 case 'b':
271 swap_bytes = 1;
272 break;
273 case 'h':
274 usage(EXIT_SUCCESS);
275 break;
276 case 'i':
277 input_file = optarg;
278 break;
279 case 'l':
280 print_all_key_names = true;
281 show_all = false;
282 name_filter = NULL;
283 break;
284 case 'n':
285 name_filter = optarg;
286 show_all = false;
287 print_all_key_names = false;
288 break;
289 case 's':
290 tffs_size = strtoul(optarg, NULL, 0);
291 break;
292 default:
293 usage(EXIT_FAILURE);
294 break;
295 }
296 }
297  
298 if (!input_file) {
299 fprintf(stderr, "ERROR: No input file (-i <file>) given!\n");
300 exit(EXIT_FAILURE);
301 }
302  
303 if (!file_exist(input_file)) {
304 fprintf(stderr, "ERROR: %s does not exist\n", input_file);
305 exit(EXIT_FAILURE);
306 }
307  
308 if (!show_all && !name_filter && !print_all_key_names) {
309 fprintf(stderr,
310 "ERROR: either -l, -a or -n <key name> is required!\n");
311 exit(EXIT_FAILURE);
312 }
313 }
314  
315 int main(int argc, char *argv[])
316 {
317 int ret = EXIT_FAILURE;
318 uint8_t *buffer;
319 FILE *fp;
320 struct tffs_entry name_table;
321 struct tffs_key_name_table key_names;
322  
323 progname = basename(argv[0]);
324  
325 parse_options(argc, argv);
326  
327 fp = fopen(input_file, "r");
328  
329 if (!fp) {
330 fprintf(stderr, "ERROR: Failed to open tffs input file %s\n",
331 input_file);
332 goto out;
333 }
334  
335 if (tffs_size == 0) {
336 fseek(fp, 0L, SEEK_END);
337 tffs_size = ftell(fp);
338 fseek(fp, 0L, SEEK_SET);
339 }
340  
341 buffer = malloc(tffs_size);
342  
343 if (fread(buffer, 1, tffs_size, fp) != tffs_size) {
344 fprintf(stderr, "ERROR: Failed read tffs file %s\n",
345 input_file);
346 goto out_free;
347 }
348  
349 if (!find_entry(buffer, TFFS_ID_TABLE_NAME, &name_table)) {
350 fprintf(stderr,"ERROR: No name table found in tffs file %s\n",
351 input_file);
352 fprintf(stderr," Is byte-swapping (-b) required?\n");
353 goto out_free;
354 }
355  
356 parse_key_names(&name_table, &key_names);
357 if (key_names.size < 1) {
358 fprintf(stderr, "ERROR: No name table found in tffs file %s\n",
359 input_file);
360 goto out_free_names;
361 }
362  
363 if (print_all_key_names) {
364 show_all_key_names(&key_names);
365 ret = EXIT_SUCCESS;
366 } else if (show_all) {
367 ret = show_all_key_value_pairs(buffer, &key_names);
368 } else {
369 ret = show_matching_key_value(buffer, &key_names);
370 }
371  
372 out_free_names:
373 free(key_names.entries);
374 out_free:
375 fclose(fp);
376 free(buffer);
377 out:
378 return ret;
379 }