ASoC: tpa6130a2: Update e-mail address
[linux-2.6.git] / usr / gen_init_cpio.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <sys/types.h>
4 #include <sys/stat.h>
5 #include <string.h>
6 #include <unistd.h>
7 #include <time.h>
8 #include <fcntl.h>
9 #include <errno.h>
10 #include <ctype.h>
11 #include <limits.h>
12
13 /*
14  * Original work by Jeff Garzik
15  *
16  * External file lists, symlink, pipe and fifo support by Thayne Harbaugh
17  * Hard link support by Luciano Rocha
18  */
19
20 #define xstr(s) #s
21 #define str(s) xstr(s)
22
23 static unsigned int offset;
24 static unsigned int ino = 721;
25
26 struct file_handler {
27         const char *type;
28         int (*handler)(const char *line);
29 };
30
31 static void push_string(const char *name)
32 {
33         unsigned int name_len = strlen(name) + 1;
34
35         fputs(name, stdout);
36         putchar(0);
37         offset += name_len;
38 }
39
40 static void push_pad (void)
41 {
42         while (offset & 3) {
43                 putchar(0);
44                 offset++;
45         }
46 }
47
48 static void push_rest(const char *name)
49 {
50         unsigned int name_len = strlen(name) + 1;
51         unsigned int tmp_ofs;
52
53         fputs(name, stdout);
54         putchar(0);
55         offset += name_len;
56
57         tmp_ofs = name_len + 110;
58         while (tmp_ofs & 3) {
59                 putchar(0);
60                 offset++;
61                 tmp_ofs++;
62         }
63 }
64
65 static void push_hdr(const char *s)
66 {
67         fputs(s, stdout);
68         offset += 110;
69 }
70
71 static void cpio_trailer(void)
72 {
73         char s[256];
74         const char name[] = "TRAILER!!!";
75
76         sprintf(s, "%s%08X%08X%08lX%08lX%08X%08lX"
77                "%08X%08X%08X%08X%08X%08X%08X",
78                 "070701",               /* magic */
79                 0,                      /* ino */
80                 0,                      /* mode */
81                 (long) 0,               /* uid */
82                 (long) 0,               /* gid */
83                 1,                      /* nlink */
84                 (long) 0,               /* mtime */
85                 0,                      /* filesize */
86                 0,                      /* major */
87                 0,                      /* minor */
88                 0,                      /* rmajor */
89                 0,                      /* rminor */
90                 (unsigned)strlen(name)+1, /* namesize */
91                 0);                     /* chksum */
92         push_hdr(s);
93         push_rest(name);
94
95         while (offset % 512) {
96                 putchar(0);
97                 offset++;
98         }
99 }
100
101 static int cpio_mkslink(const char *name, const char *target,
102                          unsigned int mode, uid_t uid, gid_t gid)
103 {
104         char s[256];
105         time_t mtime = time(NULL);
106
107         if (name[0] == '/')
108                 name++;
109         sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
110                "%08X%08X%08X%08X%08X%08X%08X",
111                 "070701",               /* magic */
112                 ino++,                  /* ino */
113                 S_IFLNK | mode,         /* mode */
114                 (long) uid,             /* uid */
115                 (long) gid,             /* gid */
116                 1,                      /* nlink */
117                 (long) mtime,           /* mtime */
118                 (unsigned)strlen(target)+1, /* filesize */
119                 3,                      /* major */
120                 1,                      /* minor */
121                 0,                      /* rmajor */
122                 0,                      /* rminor */
123                 (unsigned)strlen(name) + 1,/* namesize */
124                 0);                     /* chksum */
125         push_hdr(s);
126         push_string(name);
127         push_pad();
128         push_string(target);
129         push_pad();
130         return 0;
131 }
132
133 static int cpio_mkslink_line(const char *line)
134 {
135         char name[PATH_MAX + 1];
136         char target[PATH_MAX + 1];
137         unsigned int mode;
138         int uid;
139         int gid;
140         int rc = -1;
141
142         if (5 != sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX) "s %o %d %d", name, target, &mode, &uid, &gid)) {
143                 fprintf(stderr, "Unrecognized dir format '%s'", line);
144                 goto fail;
145         }
146         rc = cpio_mkslink(name, target, mode, uid, gid);
147  fail:
148         return rc;
149 }
150
151 static int cpio_mkgeneric(const char *name, unsigned int mode,
152                        uid_t uid, gid_t gid)
153 {
154         char s[256];
155         time_t mtime = time(NULL);
156
157         if (name[0] == '/')
158                 name++;
159         sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
160                "%08X%08X%08X%08X%08X%08X%08X",
161                 "070701",               /* magic */
162                 ino++,                  /* ino */
163                 mode,                   /* mode */
164                 (long) uid,             /* uid */
165                 (long) gid,             /* gid */
166                 2,                      /* nlink */
167                 (long) mtime,           /* mtime */
168                 0,                      /* filesize */
169                 3,                      /* major */
170                 1,                      /* minor */
171                 0,                      /* rmajor */
172                 0,                      /* rminor */
173                 (unsigned)strlen(name) + 1,/* namesize */
174                 0);                     /* chksum */
175         push_hdr(s);
176         push_rest(name);
177         return 0;
178 }
179
180 enum generic_types {
181         GT_DIR,
182         GT_PIPE,
183         GT_SOCK
184 };
185
186 struct generic_type {
187         const char *type;
188         mode_t mode;
189 };
190
191 static struct generic_type generic_type_table[] = {
192         [GT_DIR] = {
193                 .type = "dir",
194                 .mode = S_IFDIR
195         },
196         [GT_PIPE] = {
197                 .type = "pipe",
198                 .mode = S_IFIFO
199         },
200         [GT_SOCK] = {
201                 .type = "sock",
202                 .mode = S_IFSOCK
203         }
204 };
205
206 static int cpio_mkgeneric_line(const char *line, enum generic_types gt)
207 {
208         char name[PATH_MAX + 1];
209         unsigned int mode;
210         int uid;
211         int gid;
212         int rc = -1;
213
214         if (4 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d", name, &mode, &uid, &gid)) {
215                 fprintf(stderr, "Unrecognized %s format '%s'",
216                         line, generic_type_table[gt].type);
217                 goto fail;
218         }
219         mode |= generic_type_table[gt].mode;
220         rc = cpio_mkgeneric(name, mode, uid, gid);
221  fail:
222         return rc;
223 }
224
225 static int cpio_mkdir_line(const char *line)
226 {
227         return cpio_mkgeneric_line(line, GT_DIR);
228 }
229
230 static int cpio_mkpipe_line(const char *line)
231 {
232         return cpio_mkgeneric_line(line, GT_PIPE);
233 }
234
235 static int cpio_mksock_line(const char *line)
236 {
237         return cpio_mkgeneric_line(line, GT_SOCK);
238 }
239
240 static int cpio_mknod(const char *name, unsigned int mode,
241                        uid_t uid, gid_t gid, char dev_type,
242                        unsigned int maj, unsigned int min)
243 {
244         char s[256];
245         time_t mtime = time(NULL);
246
247         if (dev_type == 'b')
248                 mode |= S_IFBLK;
249         else
250                 mode |= S_IFCHR;
251
252         if (name[0] == '/')
253                 name++;
254         sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
255                "%08X%08X%08X%08X%08X%08X%08X",
256                 "070701",               /* magic */
257                 ino++,                  /* ino */
258                 mode,                   /* mode */
259                 (long) uid,             /* uid */
260                 (long) gid,             /* gid */
261                 1,                      /* nlink */
262                 (long) mtime,           /* mtime */
263                 0,                      /* filesize */
264                 3,                      /* major */
265                 1,                      /* minor */
266                 maj,                    /* rmajor */
267                 min,                    /* rminor */
268                 (unsigned)strlen(name) + 1,/* namesize */
269                 0);                     /* chksum */
270         push_hdr(s);
271         push_rest(name);
272         return 0;
273 }
274
275 static int cpio_mknod_line(const char *line)
276 {
277         char name[PATH_MAX + 1];
278         unsigned int mode;
279         int uid;
280         int gid;
281         char dev_type;
282         unsigned int maj;
283         unsigned int min;
284         int rc = -1;
285
286         if (7 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d %c %u %u",
287                          name, &mode, &uid, &gid, &dev_type, &maj, &min)) {
288                 fprintf(stderr, "Unrecognized nod format '%s'", line);
289                 goto fail;
290         }
291         rc = cpio_mknod(name, mode, uid, gid, dev_type, maj, min);
292  fail:
293         return rc;
294 }
295
296 static int cpio_mkfile(const char *name, const char *location,
297                         unsigned int mode, uid_t uid, gid_t gid,
298                         unsigned int nlinks)
299 {
300         char s[256];
301         char *filebuf = NULL;
302         struct stat buf;
303         long size;
304         int file = -1;
305         int retval;
306         int rc = -1;
307         int namesize;
308         int i;
309
310         mode |= S_IFREG;
311
312         file = open (location, O_RDONLY);
313         if (file < 0) {
314                 fprintf (stderr, "File %s could not be opened for reading\n", location);
315                 goto error;
316         }
317
318         retval = fstat(file, &buf);
319         if (retval) {
320                 fprintf(stderr, "File %s could not be stat()'ed\n", location);
321                 goto error;
322         }
323
324         filebuf = malloc(buf.st_size);
325         if (!filebuf) {
326                 fprintf (stderr, "out of memory\n");
327                 goto error;
328         }
329
330         retval = read (file, filebuf, buf.st_size);
331         if (retval < 0) {
332                 fprintf (stderr, "Can not read %s file\n", location);
333                 goto error;
334         }
335
336         size = 0;
337         for (i = 1; i <= nlinks; i++) {
338                 /* data goes on last link */
339                 if (i == nlinks) size = buf.st_size;
340
341                 if (name[0] == '/')
342                         name++;
343                 namesize = strlen(name) + 1;
344                 sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
345                        "%08lX%08X%08X%08X%08X%08X%08X",
346                         "070701",               /* magic */
347                         ino,                    /* ino */
348                         mode,                   /* mode */
349                         (long) uid,             /* uid */
350                         (long) gid,             /* gid */
351                         nlinks,                 /* nlink */
352                         (long) buf.st_mtime,    /* mtime */
353                         size,                   /* filesize */
354                         3,                      /* major */
355                         1,                      /* minor */
356                         0,                      /* rmajor */
357                         0,                      /* rminor */
358                         namesize,               /* namesize */
359                         0);                     /* chksum */
360                 push_hdr(s);
361                 push_string(name);
362                 push_pad();
363
364                 if (size) {
365                         if (fwrite(filebuf, size, 1, stdout) != 1) {
366                                 fprintf(stderr, "writing filebuf failed\n");
367                                 goto error;
368                         }
369                         offset += size;
370                         push_pad();
371                 }
372
373                 name += namesize;
374         }
375         ino++;
376         rc = 0;
377         
378 error:
379         if (filebuf) free(filebuf);
380         if (file >= 0) close(file);
381         return rc;
382 }
383
384 static char *cpio_replace_env(char *new_location)
385 {
386        char expanded[PATH_MAX + 1];
387        char env_var[PATH_MAX + 1];
388        char *start;
389        char *end;
390
391        for (start = NULL; (start = strstr(new_location, "${")); ) {
392                end = strchr(start, '}');
393                if (start < end) {
394                        *env_var = *expanded = '\0';
395                        strncat(env_var, start + 2, end - start - 2);
396                        strncat(expanded, new_location, start - new_location);
397                        strncat(expanded, getenv(env_var), PATH_MAX);
398                        strncat(expanded, end + 1, PATH_MAX);
399                        strncpy(new_location, expanded, PATH_MAX);
400                } else
401                        break;
402        }
403
404        return new_location;
405 }
406
407
408 static int cpio_mkfile_line(const char *line)
409 {
410         char name[PATH_MAX + 1];
411         char *dname = NULL; /* malloc'ed buffer for hard links */
412         char location[PATH_MAX + 1];
413         unsigned int mode;
414         int uid;
415         int gid;
416         int nlinks = 1;
417         int end = 0, dname_len = 0;
418         int rc = -1;
419
420         if (5 > sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX)
421                                 "s %o %d %d %n",
422                                 name, location, &mode, &uid, &gid, &end)) {
423                 fprintf(stderr, "Unrecognized file format '%s'", line);
424                 goto fail;
425         }
426         if (end && isgraph(line[end])) {
427                 int len;
428                 int nend;
429
430                 dname = malloc(strlen(line));
431                 if (!dname) {
432                         fprintf (stderr, "out of memory (%d)\n", dname_len);
433                         goto fail;
434                 }
435
436                 dname_len = strlen(name) + 1;
437                 memcpy(dname, name, dname_len);
438
439                 do {
440                         nend = 0;
441                         if (sscanf(line + end, "%" str(PATH_MAX) "s %n",
442                                         name, &nend) < 1)
443                                 break;
444                         len = strlen(name) + 1;
445                         memcpy(dname + dname_len, name, len);
446                         dname_len += len;
447                         nlinks++;
448                         end += nend;
449                 } while (isgraph(line[end]));
450         } else {
451                 dname = name;
452         }
453         rc = cpio_mkfile(dname, cpio_replace_env(location),
454                          mode, uid, gid, nlinks);
455  fail:
456         if (dname_len) free(dname);
457         return rc;
458 }
459
460 static void usage(const char *prog)
461 {
462         fprintf(stderr, "Usage:\n"
463                 "\t%s <cpio_list>\n"
464                 "\n"
465                 "<cpio_list> is a file containing newline separated entries that\n"
466                 "describe the files to be included in the initramfs archive:\n"
467                 "\n"
468                 "# a comment\n"
469                 "file <name> <location> <mode> <uid> <gid> [<hard links>]\n"
470                 "dir <name> <mode> <uid> <gid>\n"
471                 "nod <name> <mode> <uid> <gid> <dev_type> <maj> <min>\n"
472                 "slink <name> <target> <mode> <uid> <gid>\n"
473                 "pipe <name> <mode> <uid> <gid>\n"
474                 "sock <name> <mode> <uid> <gid>\n"
475                 "\n"
476                 "<name>       name of the file/dir/nod/etc in the archive\n"
477                 "<location>   location of the file in the current filesystem\n"
478                 "             expands shell variables quoted with ${}\n"
479                 "<target>     link target\n"
480                 "<mode>       mode/permissions of the file\n"
481                 "<uid>        user id (0=root)\n"
482                 "<gid>        group id (0=root)\n"
483                 "<dev_type>   device type (b=block, c=character)\n"
484                 "<maj>        major number of nod\n"
485                 "<min>        minor number of nod\n"
486                 "<hard links> space separated list of other links to file\n"
487                 "\n"
488                 "example:\n"
489                 "# A simple initramfs\n"
490                 "dir /dev 0755 0 0\n"
491                 "nod /dev/console 0600 0 0 c 5 1\n"
492                 "dir /root 0700 0 0\n"
493                 "dir /sbin 0755 0 0\n"
494                 "file /sbin/kinit /usr/src/klibc/kinit/kinit 0755 0 0\n",
495                 prog);
496 }
497
498 struct file_handler file_handler_table[] = {
499         {
500                 .type    = "file",
501                 .handler = cpio_mkfile_line,
502         }, {
503                 .type    = "nod",
504                 .handler = cpio_mknod_line,
505         }, {
506                 .type    = "dir",
507                 .handler = cpio_mkdir_line,
508         }, {
509                 .type    = "slink",
510                 .handler = cpio_mkslink_line,
511         }, {
512                 .type    = "pipe",
513                 .handler = cpio_mkpipe_line,
514         }, {
515                 .type    = "sock",
516                 .handler = cpio_mksock_line,
517         }, {
518                 .type    = NULL,
519                 .handler = NULL,
520         }
521 };
522
523 #define LINE_SIZE (2 * PATH_MAX + 50)
524
525 int main (int argc, char *argv[])
526 {
527         FILE *cpio_list;
528         char line[LINE_SIZE];
529         char *args, *type;
530         int ec = 0;
531         int line_nr = 0;
532
533         if (2 != argc) {
534                 usage(argv[0]);
535                 exit(1);
536         }
537
538         if (!strcmp(argv[1], "-"))
539                 cpio_list = stdin;
540         else if (! (cpio_list = fopen(argv[1], "r"))) {
541                 fprintf(stderr, "ERROR: unable to open '%s': %s\n\n",
542                         argv[1], strerror(errno));
543                 usage(argv[0]);
544                 exit(1);
545         }
546
547         while (fgets(line, LINE_SIZE, cpio_list)) {
548                 int type_idx;
549                 size_t slen = strlen(line);
550
551                 line_nr++;
552
553                 if ('#' == *line) {
554                         /* comment - skip to next line */
555                         continue;
556                 }
557
558                 if (! (type = strtok(line, " \t"))) {
559                         fprintf(stderr,
560                                 "ERROR: incorrect format, could not locate file type line %d: '%s'\n",
561                                 line_nr, line);
562                         ec = -1;
563                         break;
564                 }
565
566                 if ('\n' == *type) {
567                         /* a blank line */
568                         continue;
569                 }
570
571                 if (slen == strlen(type)) {
572                         /* must be an empty line */
573                         continue;
574                 }
575
576                 if (! (args = strtok(NULL, "\n"))) {
577                         fprintf(stderr,
578                                 "ERROR: incorrect format, newline required line %d: '%s'\n",
579                                 line_nr, line);
580                         ec = -1;
581                 }
582
583                 for (type_idx = 0; file_handler_table[type_idx].type; type_idx++) {
584                         int rc;
585                         if (! strcmp(line, file_handler_table[type_idx].type)) {
586                                 if ((rc = file_handler_table[type_idx].handler(args))) {
587                                         ec = rc;
588                                         fprintf(stderr, " line %d\n", line_nr);
589                                 }
590                                 break;
591                         }
592                 }
593
594                 if (NULL == file_handler_table[type_idx].type) {
595                         fprintf(stderr, "unknown file type line %d: '%s'\n",
596                                 line_nr, line);
597                 }
598         }
599         if (ec == 0)
600                 cpio_trailer();
601
602         exit(ec);
603 }