Root/tools/firmware-utils/src/seama.c

1/* vi: set sw=4 ts=4: */
2/*
3 * Copyright (C) 2008, Alpha Networks, Inc.
4 * Created by David Hsieh <david_hsieh@alphanetworks.com>
5 * All right reserved.
6 *
7 * (SEA)ttle i(MA)ge is the image which used in project seattle.
8 *
9 * Redistribution and use in source and binary forms, with or
10 * without modification, are permitted provided that the following
11 * conditions are met:
12 *
13 * 1. Redistributions of source code must retain the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer.
16 *
17 * 2. Redistributions in binary form must reproduce the above
18 * copyright notice, this list of conditions and the following
19 * disclaimer in the documentation and/or other materials
20 * provided with the distribution.
21 *
22 * 3. The name of the author may not be used to endorse or promote
23 * products derived from this software without specific prior
24 * written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
27 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
28 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
29 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR
30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
32 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
36 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
37 * THE POSSIBILITY OF SUCH DAMAGE.
38 *
39 */
40
41#include <stdio.h>
42#include <stdint.h>
43#include <stdlib.h>
44#include <stdarg.h>
45#include <sys/types.h>
46#include <sys/stat.h>
47#include <unistd.h>
48#include <string.h>
49#include <arpa/inet.h>
50
51#include "md5.h"
52#include "seama.h"
53
54#define PROGNAME "seama"
55#define VERSION "0.20"
56#define MAX_SEAMA_META_SIZE 1024
57#define MAX_META 128
58#define MAX_IMAGE 128
59
60extern int optind;
61extern char * optarg;
62
63static int o_verbose = 0; /* verbose mode. */
64static char * o_dump = NULL; /* Seama file to dump. */
65static char * o_seal = NULL; /* Seal the input images when file name exist. */
66static char * o_extract = NULL; /* Extract the seama file. */
67static char * o_images[MAX_IMAGE];/* The image files to pack or seal */
68static int o_isize = 0; /* number of images */
69static char * o_meta[MAX_META]; /* meta data array */
70static int o_msize = 0; /* size of meta array */
71
72static void verbose(const char * format, ...)
73{
74    va_list marker;
75    if (o_verbose)
76    {
77        va_start(marker, format);
78        vfprintf(stdout, format, marker);
79        va_end(marker);
80    }
81}
82
83static void cleanup_exit(int exit_code)
84{
85    verbose("%s: exit with code %d\n", PROGNAME, exit_code);
86    exit(exit_code);
87}
88
89static void show_usage(int exit_code)
90{
91    printf( PROGNAME " version " VERSION "\n"
92            "usage: " PROGNAME " [OPTIONS]\n"
93            " -h show this help message.\n"
94            " -v verbose mode.\n"
95            " -m {META data} META data.\n"
96            " -d {file} dump the info of the seama file.\n"
97            " -i {input file} image file name.\n"
98            " -s {file} Seal the images to the seama file.\n"
99            " -x {seama file} Extract the seama file.\n"
100            "\n"
101            " SEAMA can pack the input file (with -i) into a seama file.\n"
102            " ex: seama -i target.file\n"
103            " SEAMA can also seal multiple seama files into a single seama file.\n"
104            " ex: seama -s final.file -i taget1.seama -i target2.seama\n"
105            " To extract the raw image from SEAMA, you need to specify the meta.\n"
106            " The first image match the specified meta will be extract to\n"
107            " the output file which was specified with '-x'.\n"
108            " ex: seama -x output -i seama.image -m file=sealpac\n"
109            );
110    cleanup_exit(exit_code);
111}
112
113static int parse_args(int argc, char * argv[])
114{
115    int opt;
116
117    while ((opt = getopt(argc, argv, "hvd:s:i:m:x:")) > 0)
118    {
119        switch (opt)
120        {
121        default: show_usage(-1); break;
122        case 'h': show_usage(0); break;
123        case 'v': o_verbose++; break;
124        case 'd': o_dump = optarg; break;
125        case 's': o_seal = optarg; break;
126        case 'x': o_extract = optarg; break;
127        case 'i':
128            if (o_isize < MAX_IMAGE) o_images[o_isize++] = optarg;
129            else printf("Exceed the maximum acceptable image files.!\n");
130            break;
131        case 'm':
132            if (o_msize < MAX_META) o_meta[o_msize++] = optarg;
133            else printf("Exceed the maximum acceptable META data.!\n");
134            break;
135        }
136    }
137    return 0;
138}
139
140/*******************************************************************/
141
142static size_t calculate_digest(FILE * fh, size_t size, uint8_t * digest)
143{
144    MD5_CTX ctx;
145    size_t bytes_left, bytes_read, i;
146    uint8_t buf[MAX_SEAMA_META_SIZE];
147
148    bytes_left = size ? size : sizeof(buf);
149    bytes_read = 0;
150
151    MD5_Init(&ctx);
152    while (!feof(fh) && !ferror(fh) && bytes_left > 0)
153    {
154        i = bytes_left < sizeof(buf) ? bytes_left : sizeof(buf);
155        i = fread(buf, sizeof(char), i, fh);
156        if (i > 0)
157        {
158            MD5_Update(&ctx, buf, i);
159            bytes_read += i;
160        }
161        if (size) bytes_left -= i;
162    }
163    MD5_Final(digest, &ctx);
164    return bytes_read;
165}
166
167#define READ_BUFF_SIZE 8*1024
168static size_t copy_file(FILE * to, FILE * from)
169{
170    size_t i, fsize = 0;
171    uint8_t buf[READ_BUFF_SIZE];
172
173    while (!feof(from) && !ferror(from))
174    {
175        i = fread(buf, sizeof(uint8_t), READ_BUFF_SIZE, from);
176        if (i > 0)
177        {
178            fsize += i;
179            fwrite(buf, sizeof(uint8_t), i, to);
180        }
181    }
182    return fsize;
183}
184
185static int verify_seama(const char * fname, int msg)
186{
187    FILE * fh = NULL;
188    struct stat st;
189    seamahdr_t shdr;
190    uint8_t checksum[16];
191    uint8_t digest[16];
192    uint8_t buf[MAX_SEAMA_META_SIZE];
193    size_t msize, isize, i;
194    int ret = -1;
195
196#define ERRBREAK(fmt, args...) { if (msg) printf(fmt, ##args); break; }
197
198    do
199    {
200        if (stat(fname, &st) < 0) ERRBREAK("Unable to get the info of '%s'\n",fname);
201        if ((fh = fopen(fname, "r+"))==NULL) ERRBREAK("Unable to open '%s' for reading!\n",fname);
202
203        /* Dump SEAMA header */
204        if (msg) printf("FILE - %s (%d bytes)\n", fname, (int)st.st_size);
205
206        /* SEAMA */
207        while (!feof(fh) && !ferror(fh))
208        {
209            /* read header */
210            if (fread(&shdr, sizeof(shdr), 1, fh) != 1) break;
211
212            /* Check the magic number */
213            if (shdr.magic != htonl(SEAMA_MAGIC)) ERRBREAK("Invalid SEAMA magic. Probably no more SEAMA!\n");
214
215            /* Get the size */
216            isize = ntohl(shdr.size);
217            msize = ntohs(shdr.metasize);
218
219            /* The checksum exist only if size is greater than zero. */
220            if (isize > 0)
221            {
222                if (fread(checksum, sizeof(checksum), 1, fh) != 1)
223                    ERRBREAK("Error reading checksum !\n");
224            }
225
226            /* Check the META size. */
227            if (msize > sizeof(buf)) ERRBREAK("META data in SEAMA header is too large!\n");
228
229            /* Read META data. */
230            if (fread(buf, sizeof(char), msize, fh) != msize)
231                ERRBREAK("Unable to read SEAMA META data!\n");
232
233            /* dump header */
234            if (msg)
235            {
236                printf("SEAMA ==========================================\n");
237                printf(" magic : %08x\n", ntohl(shdr.magic));
238                printf(" meta size : %d bytes\n", msize);
239                for (i=0; i<msize; i+=(strlen((const char *)&buf[i])+1))
240                    printf(" meta data : %s\n", &buf[i]);
241                printf(" image size : %d bytes\n", isize);
242            }
243
244            /* verify checksum */
245            if (isize > 0)
246            {
247                if (msg)
248                {
249                    printf(" checksum : ");
250                    for (i=0; i<16; i++) printf("%02X", checksum[i]);
251                    printf("\n");
252                }
253
254                /* Calculate the checksum */
255                calculate_digest(fh, isize, digest);
256                if (msg)
257                {
258                    printf(" digest : ");
259                    for (i=0; i<16; i++) printf("%02X", digest[i]);
260                    printf("\n");
261                }
262
263                if (memcmp(checksum, digest, 16)!=0) ERRBREAK("!!ERROR!! checksum error !!\n");
264                ret = 0;
265            }
266        }
267        if (msg) printf("================================================\n");
268    } while (0);
269    if (fh) fclose(fh);
270    return ret;
271}
272
273static size_t write_seama_header(FILE * fh, char * meta[], size_t msize, size_t size)
274{
275    seamahdr_t shdr;
276    size_t i;
277    uint16_t metasize = 0;
278
279    /* Calculate the META size */
280    for (i=0; i<msize; i++) metasize += (strlen(meta[i]) + 1);
281    //+++ let meta data end on 4 alignment by siyou. 2010/3/1 03:58pm
282    metasize = ((metasize+3)/4)*4;
283    verbose("SEAMA META : %d bytes\n", metasize);
284
285    /* Fill up the header, all the data endian should be network byte order. */
286    shdr.magic = htonl(SEAMA_MAGIC);
287    shdr.reserved = 0;
288    shdr.metasize = htons(metasize);
289    shdr.size = htonl(size);
290
291    /* Write the header */
292    return fwrite(&shdr, sizeof(seamahdr_t), 1, fh);
293}
294
295static size_t write_checksum(FILE * fh, uint8_t * checksum)
296{
297    return fwrite(checksum, sizeof(uint8_t), 16, fh);
298}
299
300static size_t write_meta_data(FILE * fh, char * meta[], size_t size)
301{
302    size_t i,j;
303    size_t ret = 0;
304
305    for (i=0; i<size; i++)
306    {
307        verbose("SEAMA META data : %s\n", meta[i]);
308        j = fwrite(meta[i], sizeof(char), strlen(meta[i])+1, fh);
309        if (j != strlen(meta[i])+1) return 0;
310        ret += j;
311    }
312    //+++ let meta data end on 4 alignment by siyou. 2010/3/1 03:58pm
313    j = ((ret+3)/4)*4;
314    for ( ; ret < j; ret++)
315        fwrite("", sizeof(char), 1, fh);
316
317    return ret;
318}
319
320/*******************************************************************/
321
322static void dump_seama(const char * fname)
323{
324    verify_seama(fname, 1);
325}
326
327static void seal_files(const char * file)
328{
329    FILE * fh;
330    FILE * ifh;
331    size_t i;
332
333    /* Each image should be seama. */
334    for (i = 0; i < o_isize; i++)
335    {
336        if (verify_seama(o_images[i], 0) < 0)
337        {
338            printf("'%s' is not a seama file !\n",o_images[i]);
339            return;
340        }
341    }
342
343    /* Open file for write */
344    fh = fopen(file, "w+");
345    if (fh)
346    {
347        /* Write the header. */
348        write_seama_header(fh, o_meta, o_msize, 0);
349        write_meta_data(fh, o_meta, o_msize);
350
351        /* Write image files */
352        for (i=0; i<o_isize; i++)
353        {
354            ifh = fopen(o_images[i], "r+");
355            if (ifh)
356            {
357                copy_file(fh, ifh);
358                fclose(ifh);
359            }
360        }
361
362        fclose(fh);
363    }
364}
365
366static void pack_files(void)
367{
368    FILE * fh;
369    FILE * ifh;
370    size_t i, fsize;
371    char filename[512];
372    uint8_t digest[16];
373
374    for (i=0; i<o_isize; i++)
375    {
376        /* Open the input file. */
377        ifh = fopen(o_images[i], "r+");
378        if (ifh)
379        {
380            fsize = calculate_digest(ifh, 0, digest);
381            verbose("file size (%s) : %d\n", o_images[i], fsize);
382            rewind(ifh);
383
384            /* Open the output file. */
385            sprintf(filename, "%s.seama", o_images[i]);
386            fh = fopen(filename, "w+");
387            if (fh)
388            {
389                write_seama_header(fh, o_meta, o_msize, fsize);
390                write_checksum(fh, digest);
391                write_meta_data(fh, o_meta, o_msize);
392                copy_file(fh, ifh);
393                fclose(fh);
394            }
395            fclose(ifh);
396        }
397        else
398        {
399            printf("Unable to open image file '%s'\n",o_images[i]);
400        }
401    }
402}
403
404/**************************************************************************/
405
406static int match_meta(const char * meta, size_t size)
407{
408    size_t i, j;
409    int match;
410
411    for (i = 0; i < o_msize; i++)
412    {
413        for (match = 0, j = 0; j < size; j += (strlen(&meta[j])+1))
414            if (strcmp(&meta[j], o_meta[i])==0) { match++; break; }
415        if (!match) return 0;
416    }
417    return 1;
418}
419
420
421static void extract_file(const char * output)
422{
423    FILE * ifh = NULL;
424    FILE * ofh = NULL;
425    size_t msize, isize, i, m;
426    seamahdr_t shdr;
427    uint8_t buf[MAX_SEAMA_META_SIZE];
428    int done = 0;
429
430    /* We need meta for searching the target image. */
431    if (o_msize == 0)
432    {
433        printf("SEAMA: need meta for searching image.\n");
434        return;
435    }
436
437    /* Walk through each input file */
438    for (i = 0; i < o_isize; i++)
439    {
440        /* verify the input file */
441        if (verify_seama(o_images[i], 0) < 0)
442        {
443            printf("SEAMA: '%s' is not a seama file !\n", o_images[i]);
444            continue;
445        }
446        /* open the input file */
447        ifh = fopen(o_images[i], "r");
448        if (!ifh) continue;
449        /* read file */
450        while (!feof(ifh) && !ferror(ifh))
451        {
452            /* read header */
453            fread(&shdr, sizeof(shdr), 1, ifh);
454            if (shdr.magic != htonl(SEAMA_MAGIC)) break;
455            /* Get the size */
456            isize = ntohl(shdr.size);
457            msize = ntohs(shdr.metasize);
458            if (isize == 0)
459            {
460                while (msize > 0)
461                {
462                    m = fread(buf, sizeof(char), (msize < MAX_SEAMA_META_SIZE) ? msize : MAX_SEAMA_META_SIZE, ifh);
463                    if (m <= 0) break;
464                    msize -= m;
465                }
466                continue;
467            }
468            /* read checksum */
469            fread(buf, sizeof(char), 16, ifh);
470            if (msize > 0)
471            {
472                /* read META */
473                fread(buf, sizeof(char), msize, ifh);
474                if (match_meta((const char *)buf, msize))
475                {
476                    printf("SEAMA: found image @ '%s', image size: %d\n", o_images[i], isize);
477                    /* open output file */
478                    ofh = fopen(output, "w");
479                    if (!ofh) printf("SEAMA: unable to open '%s' for writting.\n",output);
480                    else
481                    {
482                        while (isize > 0)
483                        {
484                            m = fread(buf, sizeof(char), (isize < MAX_SEAMA_META_SIZE) ? isize : MAX_SEAMA_META_SIZE, ifh);
485                            if (m <= 0) break;
486                            fwrite(buf, sizeof(char), m, ofh);
487                            isize -= m;
488                        }
489                        fclose(ofh);
490                    }
491                    done++;
492                    break;
493                }
494            }
495            while (isize > 0)
496            {
497                m = fread(buf, sizeof(char), (isize < MAX_SEAMA_META_SIZE) ? isize : MAX_SEAMA_META_SIZE, ifh);
498                if (m <= 0) break;
499                isize -= m;
500            }
501        }
502        /* close the file. */
503        fclose(ifh);
504        if (done) break;
505    }
506    return;
507}
508
509/*******************************************************************/
510#ifdef RGBIN_BOX
511int seama_main(int argc, char * argv[], char * env[])
512#else
513int main(int argc, char * argv[], char * env[])
514#endif
515{
516    verbose("SEAMA version " VERSION "\n");
517
518    /* parse the arguments */
519    if (parse_args(argc, argv) < 0) show_usage(9);
520
521    /* Do the works */
522    if (o_dump) dump_seama(o_dump);
523    else if (o_seal) seal_files(o_seal);
524    else if (o_extract) extract_file(o_extract);
525    else pack_files();
526
527    cleanup_exit(0);
528    return 0;
529}
530

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive