diff options
Diffstat (limited to '')
-rw-r--r-- | libraries/eet/src/bin/eet_main.c | 507 |
1 files changed, 0 insertions, 507 deletions
diff --git a/libraries/eet/src/bin/eet_main.c b/libraries/eet/src/bin/eet_main.c deleted file mode 100644 index 8a93d11..0000000 --- a/libraries/eet/src/bin/eet_main.c +++ /dev/null | |||
@@ -1,507 +0,0 @@ | |||
1 | #ifdef HAVE_CONFIG_H | ||
2 | # include <config.h> | ||
3 | #endif /* ifdef HAVE_CONFIG_H */ | ||
4 | |||
5 | #include <stdio.h> | ||
6 | #include <stdlib.h> | ||
7 | #include <string.h> | ||
8 | |||
9 | #ifdef HAVE_UNISTD_H | ||
10 | # include <unistd.h> | ||
11 | #endif /* ifdef HAVE_UNISTD_H */ | ||
12 | |||
13 | #ifdef HAVE_EVIL | ||
14 | # include <Evil.h> | ||
15 | #endif /* ifdef HAVE_EVIL */ | ||
16 | |||
17 | #include <Eet.h> | ||
18 | |||
19 | static int _eet_main_log_dom = -1; | ||
20 | |||
21 | #ifdef EET_DEFAULT_LOG_COLOR | ||
22 | #undef EET_DEFAULT_LOG_COLOR | ||
23 | #endif /* ifdef EET_DEFAULT_LOG_COLOR */ | ||
24 | #define EET_DEFAULT_LOG_COLOR EINA_COLOR_CYAN | ||
25 | #ifdef ERR | ||
26 | #undef ERR | ||
27 | #endif /* ifdef ERR */ | ||
28 | #define ERR(...) EINA_LOG_DOM_ERR(_eet_main_log_dom, __VA_ARGS__) | ||
29 | #ifdef DBG | ||
30 | #undef DBG | ||
31 | #endif /* ifdef DBG */ | ||
32 | #define DBG(...) EINA_LOG_DOM_DBG(_eet_main_log_dom, __VA_ARGS__) | ||
33 | #ifdef INF | ||
34 | #undef INF | ||
35 | #endif /* ifdef INF */ | ||
36 | #define INF(...) EINA_LOG_DOM_INFO(_eet_main_log_dom, __VA_ARGS__) | ||
37 | #ifdef WRN | ||
38 | #undef WRN | ||
39 | #endif /* ifdef WRN */ | ||
40 | #define WRN(...) EINA_LOG_DOM_WARN(_eet_main_log_dom, __VA_ARGS__) | ||
41 | #ifdef CRIT | ||
42 | #undef CRIT | ||
43 | #endif /* ifdef CRIT */ | ||
44 | #define CRIT(...) EINA_LOG_DOM_CRIT(_eet_main_log_dom, __VA_ARGS__) | ||
45 | |||
46 | static void | ||
47 | do_eet_list(const char *file) | ||
48 | { | ||
49 | int i, num; | ||
50 | char **list; | ||
51 | Eet_File *ef; | ||
52 | |||
53 | ef = eet_open(file, EET_FILE_MODE_READ); | ||
54 | if (!ef) | ||
55 | { | ||
56 | ERR("cannot open for reading: %s", file); | ||
57 | exit(-1); | ||
58 | } | ||
59 | |||
60 | list = eet_list(ef, "*", &num); | ||
61 | if (list) | ||
62 | { | ||
63 | for (i = 0; i < num; i++) | ||
64 | printf("%s\n", list[i]); | ||
65 | free(list); | ||
66 | } | ||
67 | |||
68 | eet_close(ef); | ||
69 | } /* do_eet_list */ | ||
70 | |||
71 | static void | ||
72 | do_eet_stats(const char *file) | ||
73 | { | ||
74 | int i, num; | ||
75 | int count[2] = { 0, 0 }; | ||
76 | int size[2] = { 0, 0 }; | ||
77 | char **list; | ||
78 | Eet_File *ef; | ||
79 | Eet_Dictionary *ed; | ||
80 | |||
81 | ef = eet_open(file, EET_FILE_MODE_READ); | ||
82 | if (!ef) | ||
83 | { | ||
84 | ERR("cannot open for reading: %s", file); | ||
85 | exit(-1); | ||
86 | } | ||
87 | |||
88 | printf("*** sections stats ***\n"); | ||
89 | list = eet_list(ef, "*", &num); | ||
90 | if (list) | ||
91 | { | ||
92 | for (i = 0; i < num; i++) | ||
93 | { | ||
94 | const void *ro = NULL; | ||
95 | void *rw = NULL; | ||
96 | int tsize; | ||
97 | |||
98 | ro = eet_read_direct(ef, list[i], &tsize); | ||
99 | if (!ro) rw = eet_read(ef, list[i], &tsize); | ||
100 | printf(rw ? "%s of size %i is compressed.\n" : "%s of size %i is not compressed.\n", list[i], tsize); | ||
101 | count[rw ? 0 : 1]++; | ||
102 | size[rw ? 0 : 1] += tsize; | ||
103 | free(rw); | ||
104 | } | ||
105 | free(list); | ||
106 | } | ||
107 | |||
108 | printf("*** dictionary ***\n"); | ||
109 | ed = eet_dictionary_get(ef); | ||
110 | if (ed) | ||
111 | { | ||
112 | printf("%i strings inside the dictionary.\n", eet_dictionary_count(ed)); | ||
113 | } | ||
114 | else | ||
115 | { | ||
116 | printf("no dictionary in this file.\n"); | ||
117 | } | ||
118 | printf("*** global ***\n"); | ||
119 | printf("%i sections\n", num); | ||
120 | printf("- %i of them are compressed (%02.2f%%) expanding in %i bytes.\n", | ||
121 | count[0], (float) count[0] * 100 / (float) num, size[0]); | ||
122 | printf("- %i of them are directly mappable in memory (%02.2f%%) representing %i bytes.\n", | ||
123 | count[1], (float) count[1] * 100 / (float) num, size[1]); | ||
124 | |||
125 | eet_close(ef); | ||
126 | } | ||
127 | |||
128 | static void | ||
129 | do_eet_extract(const char *file, | ||
130 | const char *key, | ||
131 | const char *out, | ||
132 | const char *crypto_key) | ||
133 | { | ||
134 | Eet_File *ef; | ||
135 | void *data; | ||
136 | int size = 0; | ||
137 | FILE *f = stdout; | ||
138 | |||
139 | ef = eet_open(file, EET_FILE_MODE_READ); | ||
140 | if (!ef) | ||
141 | { | ||
142 | ERR("cannot open for reading: %s", file); | ||
143 | exit(-1); | ||
144 | } | ||
145 | |||
146 | data = eet_read_cipher(ef, key, &size, crypto_key); | ||
147 | if (!data) | ||
148 | { | ||
149 | ERR("cannot read key %s", key); | ||
150 | exit(-1); | ||
151 | } | ||
152 | |||
153 | if (out) | ||
154 | { | ||
155 | f = fopen(out, "wb"); | ||
156 | if (!f) | ||
157 | { | ||
158 | ERR("cannot open %s", out); | ||
159 | exit(-1); | ||
160 | } | ||
161 | } | ||
162 | |||
163 | if (fwrite(data, size, 1, f) != 1) | ||
164 | { | ||
165 | ERR("cannot write to %s", out ? out : "standard output"); | ||
166 | exit(-1); | ||
167 | } | ||
168 | |||
169 | if (out) fclose(f); | ||
170 | free(data); | ||
171 | eet_close(ef); | ||
172 | } /* do_eet_extract */ | ||
173 | |||
174 | static void | ||
175 | do_eet_decode_dump(void *data, | ||
176 | const char *str) | ||
177 | { | ||
178 | fputs(str, (FILE *)data); | ||
179 | } /* do_eet_decode_dump */ | ||
180 | |||
181 | static void | ||
182 | do_eet_decode(const char *file, | ||
183 | const char *key, | ||
184 | const char *out, | ||
185 | const char *crypto_key) | ||
186 | { | ||
187 | Eet_File *ef; | ||
188 | FILE *f = stdout; | ||
189 | |||
190 | ef = eet_open(file, EET_FILE_MODE_READ); | ||
191 | if (!ef) | ||
192 | { | ||
193 | ERR("cannot open for reading: %s", file); | ||
194 | exit(-1); | ||
195 | } | ||
196 | |||
197 | if (out) | ||
198 | { | ||
199 | f = fopen(out, "wb"); | ||
200 | if (!f) | ||
201 | { | ||
202 | ERR("cannot open %s", out); | ||
203 | exit(-1); | ||
204 | } | ||
205 | } | ||
206 | |||
207 | if (!eet_data_dump_cipher(ef, key, crypto_key, do_eet_decode_dump, f)) | ||
208 | { | ||
209 | ERR("cannot write to %s", out ? out : "standard output"); | ||
210 | exit(-1); | ||
211 | } | ||
212 | |||
213 | if (out) fclose(f); | ||
214 | eet_close(ef); | ||
215 | } /* do_eet_decode */ | ||
216 | |||
217 | static void | ||
218 | do_eet_insert(const char *file, | ||
219 | const char *key, | ||
220 | const char *out, | ||
221 | int compress, | ||
222 | const char *crypto_key) | ||
223 | { | ||
224 | Eet_File *ef; | ||
225 | void *data; | ||
226 | int size = 0; | ||
227 | FILE *f; | ||
228 | |||
229 | ef = eet_open(file, EET_FILE_MODE_READ_WRITE); | ||
230 | if (!ef) | ||
231 | ef = eet_open(file, EET_FILE_MODE_WRITE); | ||
232 | |||
233 | if (!ef) | ||
234 | { | ||
235 | ERR("cannot open for read+write: %s", file); | ||
236 | exit(-1); | ||
237 | } | ||
238 | |||
239 | f = fopen(out, "rb"); | ||
240 | if (!f) | ||
241 | { | ||
242 | ERR("cannot open %s", out); | ||
243 | exit(-1); | ||
244 | } | ||
245 | |||
246 | fseek(f, 0, SEEK_END); | ||
247 | size = ftell(f); | ||
248 | rewind(f); | ||
249 | data = malloc(size); | ||
250 | if (!data) | ||
251 | { | ||
252 | ERR("cannot allocate %i bytes", size); | ||
253 | exit(-1); | ||
254 | } | ||
255 | |||
256 | if (fread(data, size, 1, f) != 1) | ||
257 | { | ||
258 | ERR("cannot read file %s", out); | ||
259 | exit(-1); | ||
260 | } | ||
261 | |||
262 | fclose(f); | ||
263 | eet_write_cipher(ef, key, data, size, compress, crypto_key); | ||
264 | free(data); | ||
265 | eet_close(ef); | ||
266 | } /* do_eet_insert */ | ||
267 | |||
268 | static void | ||
269 | do_eet_encode(const char *file, | ||
270 | const char *key, | ||
271 | const char *out, | ||
272 | int compress, | ||
273 | const char *crypto_key) | ||
274 | { | ||
275 | Eet_File *ef; | ||
276 | char *text; | ||
277 | int textlen = 0; | ||
278 | int size = 0; | ||
279 | FILE *f; | ||
280 | |||
281 | ef = eet_open(file, EET_FILE_MODE_READ_WRITE); | ||
282 | if (!ef) | ||
283 | ef = eet_open(file, EET_FILE_MODE_WRITE); | ||
284 | |||
285 | if (!ef) | ||
286 | { | ||
287 | ERR("cannot open for read+write: %s", file); | ||
288 | exit(-1); | ||
289 | } | ||
290 | |||
291 | f = fopen(out, "rb"); | ||
292 | if (!f) | ||
293 | { | ||
294 | ERR("cannot open %s", out); | ||
295 | exit(-1); | ||
296 | } | ||
297 | |||
298 | fseek(f, 0, SEEK_END); | ||
299 | textlen = ftell(f); | ||
300 | rewind(f); | ||
301 | text = malloc(textlen); | ||
302 | if (!text) | ||
303 | { | ||
304 | ERR("cannot allocate %i bytes", size); | ||
305 | exit(-1); | ||
306 | } | ||
307 | |||
308 | if (fread(text, textlen, 1, f) != 1) | ||
309 | { | ||
310 | ERR("cannot read file %s", out); | ||
311 | exit(-1); | ||
312 | } | ||
313 | |||
314 | fclose(f); | ||
315 | if (!eet_data_undump_cipher(ef, key, crypto_key, text, textlen, compress)) | ||
316 | { | ||
317 | ERR("cannot parse %s", out); | ||
318 | exit(-1); | ||
319 | } | ||
320 | |||
321 | free(text); | ||
322 | eet_close(ef); | ||
323 | } /* do_eet_encode */ | ||
324 | |||
325 | static void | ||
326 | do_eet_remove(const char *file, | ||
327 | const char *key) | ||
328 | { | ||
329 | Eet_File *ef; | ||
330 | |||
331 | ef = eet_open(file, EET_FILE_MODE_READ_WRITE); | ||
332 | if (!ef) | ||
333 | { | ||
334 | ERR("cannot open for read+write: %s", file); | ||
335 | exit(-1); | ||
336 | } | ||
337 | |||
338 | eet_delete(ef, key); | ||
339 | eet_close(ef); | ||
340 | } /* do_eet_remove */ | ||
341 | |||
342 | static void | ||
343 | do_eet_check(const char *file) | ||
344 | { | ||
345 | Eet_File *ef; | ||
346 | const void *der; | ||
347 | int der_length; | ||
348 | int sign_length; | ||
349 | |||
350 | ef = eet_open(file, EET_FILE_MODE_READ); | ||
351 | if (!ef) | ||
352 | { | ||
353 | ERR("checking signature of `%s` failed", file); | ||
354 | exit(-1); | ||
355 | } | ||
356 | |||
357 | der = eet_identity_x509(ef, &der_length); | ||
358 | |||
359 | fprintf(stdout, "Certificate length %i.\n", der_length); | ||
360 | eet_identity_certificate_print(der, der_length, stdout); | ||
361 | |||
362 | eet_identity_signature(ef, &sign_length); | ||
363 | fprintf(stdout, "Signature length %i.\n", sign_length); | ||
364 | |||
365 | eet_close(ef); | ||
366 | } /* do_eet_check */ | ||
367 | |||
368 | static void | ||
369 | do_eet_sign(const char *file, | ||
370 | const char *private_key, | ||
371 | const char *public_key) | ||
372 | { | ||
373 | Eet_File *ef; | ||
374 | Eet_Key *key; | ||
375 | |||
376 | ef = eet_open(file, EET_FILE_MODE_READ_WRITE); | ||
377 | if (!ef) | ||
378 | { | ||
379 | ERR("cannot open for read+write: %s.", file); | ||
380 | exit(-1); | ||
381 | } | ||
382 | |||
383 | key = eet_identity_open(public_key, private_key, NULL); | ||
384 | if (!key) | ||
385 | { | ||
386 | ERR("cannot open key '%s:%s'.", public_key, private_key); | ||
387 | exit(-1); | ||
388 | } | ||
389 | |||
390 | fprintf(stdout, "Using the following key to sign `%s`.\n", file); | ||
391 | eet_identity_print(key, stdout); | ||
392 | |||
393 | eet_identity_set(ef, key); | ||
394 | |||
395 | eet_close(ef); | ||
396 | } /* do_eet_sign */ | ||
397 | |||
398 | int | ||
399 | main(int argc, | ||
400 | char **argv) | ||
401 | { | ||
402 | if (!eet_init()) | ||
403 | return -1; | ||
404 | |||
405 | _eet_main_log_dom = eina_log_domain_register("eet_main", EINA_COLOR_CYAN); | ||
406 | if(_eet_main_log_dom < -1) | ||
407 | { | ||
408 | EINA_LOG_ERR("Impossible to create a log domain for eet_main."); | ||
409 | eet_shutdown(); | ||
410 | return -1; | ||
411 | } | ||
412 | |||
413 | if (argc < 2) | ||
414 | { | ||
415 | help: | ||
416 | printf( | ||
417 | "Usage:\n" | ||
418 | " eet -l FILE.EET list all keys in FILE.EET\n" | ||
419 | " eet -x FILE.EET KEY [OUT-FILE] [CRYPTO_KEY] extract data stored in KEY in FILE.EET and write to OUT-FILE or standard output\n" | ||
420 | " eet -d FILE.EET KEY [OUT-FILE] [CRYPTO_KEY] extract and decode data stored in KEY in FILE.EET and write to OUT-FILE or standard output\n" | ||
421 | " eet -i FILE.EET KEY IN-FILE COMPRESS [CRYPTO_KEY] insert data to KEY in FILE.EET from IN-FILE and if COMPRESS is 1, compress it\n" | ||
422 | " eet -e FILE.EET KEY IN-FILE COMPRESS [CRYPTO_KEY] insert and encode to KEY in FILE.EET from IN-FILE and if COMPRESS is 1, compress it\n" | ||
423 | " eet -r FILE.EET KEY remove KEY in FILE.EET\n" | ||
424 | " eet -c FILE.EET report and check the signature information of an eet file\n" | ||
425 | " eet -s FILE.EET PRIVATE_KEY PUBLIC_KEY sign FILE.EET with PRIVATE_KEY and attach PUBLIC_KEY as it's certificate\n" | ||
426 | " eet -t FILE.EET give some statistic about a file\n" | ||
427 | ); | ||
428 | eet_shutdown(); | ||
429 | return -1; | ||
430 | } | ||
431 | |||
432 | if ((!strncmp(argv[1], "-h", 2))) | ||
433 | goto help; | ||
434 | else if ((!strcmp(argv[1], "-l")) && (argc > 2)) | ||
435 | do_eet_list(argv[2]); | ||
436 | else if ((!strcmp(argv[1], "-x")) && (argc > 3)) | ||
437 | { | ||
438 | switch (argc) | ||
439 | { | ||
440 | case 4: | ||
441 | { | ||
442 | do_eet_extract(argv[2], argv[3], NULL, NULL); | ||
443 | break; | ||
444 | } | ||
445 | case 5: | ||
446 | { | ||
447 | do_eet_extract(argv[2], argv[3], argv[4], NULL); | ||
448 | break; | ||
449 | } | ||
450 | default: | ||
451 | { | ||
452 | do_eet_extract(argv[2], argv[3], argv[4], argv[5]); | ||
453 | break; | ||
454 | } | ||
455 | } | ||
456 | } | ||
457 | else if ((!strcmp(argv[1], "-d")) && (argc > 3)) | ||
458 | { | ||
459 | switch (argc) | ||
460 | { | ||
461 | case 4: | ||
462 | { | ||
463 | do_eet_decode(argv[2], argv[3], NULL, NULL); | ||
464 | break; | ||
465 | } | ||
466 | case 5: | ||
467 | { | ||
468 | do_eet_decode(argv[2], argv[3], argv[4], NULL); | ||
469 | break; | ||
470 | } | ||
471 | default: | ||
472 | { | ||
473 | do_eet_decode(argv[2], argv[3], argv[4], argv[5]); | ||
474 | break; | ||
475 | } | ||
476 | } | ||
477 | } | ||
478 | else if ((!strcmp(argv[1], "-i")) && (argc > 5)) | ||
479 | { | ||
480 | if (argc > 6) | ||
481 | do_eet_insert(argv[2], argv[3], argv[4], atoi(argv[5]), argv[6]); | ||
482 | else | ||
483 | do_eet_insert(argv[2], argv[3], argv[4], atoi(argv[5]), NULL); | ||
484 | } | ||
485 | else if ((!strcmp(argv[1], "-e")) && (argc > 5)) | ||
486 | { | ||
487 | if (argc > 6) | ||
488 | do_eet_encode(argv[2], argv[3], argv[4], atoi(argv[5]), argv[6]); | ||
489 | else | ||
490 | do_eet_encode(argv[2], argv[3], argv[4], atoi(argv[5]), NULL); | ||
491 | } | ||
492 | else if ((!strcmp(argv[1], "-r")) && (argc > 3)) | ||
493 | do_eet_remove(argv[2], argv[3]); | ||
494 | else if ((!strcmp(argv[1], "-c")) && (argc > 2)) | ||
495 | do_eet_check(argv[2]); | ||
496 | else if ((!strcmp(argv[1], "-s")) && (argc > 4)) | ||
497 | do_eet_sign(argv[2], argv[3], argv[4]); | ||
498 | else if ((!strcmp(argv[1], "-t")) && (argc > 2)) | ||
499 | do_eet_stats(argv[2]); | ||
500 | else | ||
501 | goto help; | ||
502 | |||
503 | eina_log_domain_unregister(_eet_main_log_dom); | ||
504 | eet_shutdown(); | ||
505 | return 0; | ||
506 | } /* main */ | ||
507 | |||