projects/linux·blob master · refs

781 lines · 17.1 KiB

1// SPDX-License-Identifier: GPL-2.0
2#define _GNU_SOURCE
3#include <stdio.h>
4#include <stdlib.h>
5#include <stdint.h>
6#include <stdbool.h>
7#include <sys/types.h>
8#include <sys/stat.h>
9#include <string.h>
10#include <unistd.h>
11#include <time.h>
12#include <fcntl.h>
13#include <errno.h>
14#include <ctype.h>
15#include <limits.h>
16
17/*
18 * Original work by Jeff Garzik
19 *
20 * External file lists, symlink, pipe and fifo support by Thayne Harbaugh
21 * Hard link support by Luciano Rocha
22 */
23
24#define xstr(s) #s
25#define str(s) xstr(s)
26#define MIN(a, b) ((a) < (b) ? (a) : (b))
27#define CPIO_HDR_LEN 110
28#define CPIO_TRAILER "TRAILER!!!"
29#define padlen(_off, _align) (((_align) - ((_off) & ((_align) - 1))) % (_align))
30
31/* zero-padding the filename field for data alignment is limited by PATH_MAX */
32static char padding[PATH_MAX];
33static unsigned int offset;
34static unsigned int ino = 721;
35static time_t default_mtime;
36static bool do_file_mtime;
37static bool do_csum = false;
38static int outfd = STDOUT_FILENO;
39static unsigned int dalign;
40
41struct file_handler {
42 const char *type;
43 int (*handler)(const char *line);
44};
45
46static int push_buf(const char *name, size_t name_len)
47{
48 ssize_t len;
49
50 len = write(outfd, name, name_len);
51 if (len != name_len)
52 return -1;
53
54 offset += name_len;
55 return 0;
56}
57
58static int push_pad(size_t padlen)
59{
60 ssize_t len = 0;
61
62 if (!padlen)
63 return 0;
64
65 if (padlen < sizeof(padding))
66 len = write(outfd, padding, padlen);
67 if (len != padlen)
68 return -1;
69
70 offset += padlen;
71 return 0;
72}
73
74static int push_rest(const char *name, size_t name_len)
75{
76 ssize_t len;
77
78 len = write(outfd, name, name_len);
79 if (len != name_len)
80 return -1;
81
82 offset += name_len;
83
84 return push_pad(padlen(name_len + CPIO_HDR_LEN, 4));
85}
86
87static int cpio_trailer(void)
88{
89 int len;
90 unsigned int namesize = sizeof(CPIO_TRAILER);
91
92 len = dprintf(outfd, "%s%08X%08X%08lX%08lX%08X%08lX"
93 "%08X%08X%08X%08X%08X%08X%08X",
94 do_csum ? "070702" : "070701", /* magic */
95 0, /* ino */
96 0, /* mode */
97 (long) 0, /* uid */
98 (long) 0, /* gid */
99 1, /* nlink */
100 (long) 0, /* mtime */
101 0, /* filesize */
102 0, /* major */
103 0, /* minor */
104 0, /* rmajor */
105 0, /* rminor */
106 namesize, /* namesize */
107 0); /* chksum */
108 offset += len;
109
110 if (len != CPIO_HDR_LEN ||
111 push_rest(CPIO_TRAILER, namesize) < 0 ||
112 push_pad(padlen(offset, 512)) < 0)
113 return -1;
114
115 if (fsync(outfd) < 0 && errno != EINVAL)
116 return -1;
117
118 return 0;
119}
120
121static int cpio_mkslink(const char *name, const char *target,
122 unsigned int mode, uid_t uid, gid_t gid)
123{
124 int len;
125 unsigned int namesize, targetsize = strlen(target) + 1;
126
127 if (name[0] == '/')
128 name++;
129 namesize = strlen(name) + 1;
130
131 len = dprintf(outfd, "%s%08X%08X%08lX%08lX%08X%08lX"
132 "%08X%08X%08X%08X%08X%08X%08X",
133 do_csum ? "070702" : "070701", /* magic */
134 ino++, /* ino */
135 S_IFLNK | mode, /* mode */
136 (long) uid, /* uid */
137 (long) gid, /* gid */
138 1, /* nlink */
139 (long) default_mtime, /* mtime */
140 targetsize, /* filesize */
141 3, /* major */
142 1, /* minor */
143 0, /* rmajor */
144 0, /* rminor */
145 namesize, /* namesize */
146 0); /* chksum */
147 offset += len;
148
149 if (len != CPIO_HDR_LEN ||
150 push_buf(name, namesize) < 0 ||
151 push_pad(padlen(offset, 4)) < 0 ||
152 push_buf(target, targetsize) < 0 ||
153 push_pad(padlen(offset, 4)) < 0)
154 return -1;
155
156 return 0;
157
158}
159
160static int cpio_mkslink_line(const char *line)
161{
162 char name[PATH_MAX + 1];
163 char target[PATH_MAX + 1];
164 unsigned int mode;
165 int uid;
166 int gid;
167 int rc = -1;
168
169 if (5 != sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX) "s %o %d %d", name, target, &mode, &uid, &gid)) {
170 fprintf(stderr, "Unrecognized dir format '%s'", line);
171 goto fail;
172 }
173 rc = cpio_mkslink(name, target, mode, uid, gid);
174 fail:
175 return rc;
176}
177
178static int cpio_mkgeneric(const char *name, unsigned int mode,
179 uid_t uid, gid_t gid)
180{
181 int len;
182 unsigned int namesize;
183
184 if (name[0] == '/')
185 name++;
186 namesize = strlen(name) + 1;
187
188 len = dprintf(outfd, "%s%08X%08X%08lX%08lX%08X%08lX"
189 "%08X%08X%08X%08X%08X%08X%08X",
190 do_csum ? "070702" : "070701", /* magic */
191 ino++, /* ino */
192 mode, /* mode */
193 (long) uid, /* uid */
194 (long) gid, /* gid */
195 2, /* nlink */
196 (long) default_mtime, /* mtime */
197 0, /* filesize */
198 3, /* major */
199 1, /* minor */
200 0, /* rmajor */
201 0, /* rminor */
202 namesize, /* namesize */
203 0); /* chksum */
204 offset += len;
205
206 if (len != CPIO_HDR_LEN ||
207 push_rest(name, namesize) < 0)
208 return -1;
209
210 return 0;
211}
212
213enum generic_types {
214 GT_DIR,
215 GT_PIPE,
216 GT_SOCK
217};
218
219struct generic_type {
220 const char *type;
221 mode_t mode;
222};
223
224static const struct generic_type generic_type_table[] = {
225 [GT_DIR] = {
226 .type = "dir",
227 .mode = S_IFDIR
228 },
229 [GT_PIPE] = {
230 .type = "pipe",
231 .mode = S_IFIFO
232 },
233 [GT_SOCK] = {
234 .type = "sock",
235 .mode = S_IFSOCK
236 }
237};
238
239static int cpio_mkgeneric_line(const char *line, enum generic_types gt)
240{
241 char name[PATH_MAX + 1];
242 unsigned int mode;
243 int uid;
244 int gid;
245 int rc = -1;
246
247 if (4 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d", name, &mode, &uid, &gid)) {
248 fprintf(stderr, "Unrecognized %s format '%s'",
249 line, generic_type_table[gt].type);
250 goto fail;
251 }
252 mode |= generic_type_table[gt].mode;
253 rc = cpio_mkgeneric(name, mode, uid, gid);
254 fail:
255 return rc;
256}
257
258static int cpio_mkdir_line(const char *line)
259{
260 return cpio_mkgeneric_line(line, GT_DIR);
261}
262
263static int cpio_mkpipe_line(const char *line)
264{
265 return cpio_mkgeneric_line(line, GT_PIPE);
266}
267
268static int cpio_mksock_line(const char *line)
269{
270 return cpio_mkgeneric_line(line, GT_SOCK);
271}
272
273static int cpio_mknod(const char *name, unsigned int mode,
274 uid_t uid, gid_t gid, char dev_type,
275 unsigned int maj, unsigned int min)
276{
277 int len;
278 unsigned int namesize;
279
280 if (dev_type == 'b')
281 mode |= S_IFBLK;
282 else
283 mode |= S_IFCHR;
284
285 if (name[0] == '/')
286 name++;
287 namesize = strlen(name) + 1;
288
289 len = dprintf(outfd, "%s%08X%08X%08lX%08lX%08X%08lX"
290 "%08X%08X%08X%08X%08X%08X%08X",
291 do_csum ? "070702" : "070701", /* magic */
292 ino++, /* ino */
293 mode, /* mode */
294 (long) uid, /* uid */
295 (long) gid, /* gid */
296 1, /* nlink */
297 (long) default_mtime, /* mtime */
298 0, /* filesize */
299 3, /* major */
300 1, /* minor */
301 maj, /* rmajor */
302 min, /* rminor */
303 namesize, /* namesize */
304 0); /* chksum */
305 offset += len;
306
307 if (len != CPIO_HDR_LEN ||
308 push_rest(name, namesize) < 0)
309 return -1;
310
311 return 0;
312}
313
314static int cpio_mknod_line(const char *line)
315{
316 char name[PATH_MAX + 1];
317 unsigned int mode;
318 int uid;
319 int gid;
320 char dev_type;
321 unsigned int maj;
322 unsigned int min;
323 int rc = -1;
324
325 if (7 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d %c %u %u",
326 name, &mode, &uid, &gid, &dev_type, &maj, &min)) {
327 fprintf(stderr, "Unrecognized nod format '%s'", line);
328 goto fail;
329 }
330 rc = cpio_mknod(name, mode, uid, gid, dev_type, maj, min);
331 fail:
332 return rc;
333}
334
335static int cpio_mkfile_csum(int fd, unsigned long size, uint32_t *csum)
336{
337 while (size) {
338 unsigned char filebuf[65536];
339 ssize_t this_read;
340 size_t i, this_size = MIN(size, sizeof(filebuf));
341
342 this_read = read(fd, filebuf, this_size);
343 if (this_read <= 0 || this_read > this_size)
344 return -1;
345
346 for (i = 0; i < this_read; i++)
347 *csum += filebuf[i];
348
349 size -= this_read;
350 }
351 /* seek back to the start for data segment I/O */
352 if (lseek(fd, 0, SEEK_SET) < 0)
353 return -1;
354
355 return 0;
356}
357
358static int cpio_mkfile(const char *name, const char *location,
359 unsigned int mode, uid_t uid, gid_t gid,
360 unsigned int nlinks)
361{
362 struct stat buf;
363 unsigned long size;
364 int file, retval, len;
365 int rc = -1;
366 time_t mtime;
367 int namesize, namepadlen;
368 unsigned int i;
369 uint32_t csum = 0;
370 ssize_t this_read;
371
372 mode |= S_IFREG;
373
374 file = open (location, O_RDONLY);
375 if (file < 0) {
376 fprintf (stderr, "File %s could not be opened for reading\n", location);
377 goto error;
378 }
379
380 retval = fstat(file, &buf);
381 if (retval) {
382 fprintf(stderr, "File %s could not be stat()'ed\n", location);
383 goto error;
384 }
385
386 if (do_file_mtime) {
387 mtime = default_mtime;
388 } else {
389 mtime = buf.st_mtime;
390 if (mtime > 0xffffffff) {
391 fprintf(stderr, "%s: Timestamp exceeds maximum cpio timestamp, clipping.\n",
392 location);
393 mtime = 0xffffffff;
394 }
395
396 if (mtime < 0) {
397 fprintf(stderr, "%s: Timestamp negative, clipping.\n",
398 location);
399 mtime = 0;
400 }
401 }
402
403 if (buf.st_size > 0xffffffff) {
404 fprintf(stderr, "%s: Size exceeds maximum cpio file size\n",
405 location);
406 goto error;
407 }
408
409 if (do_csum && cpio_mkfile_csum(file, buf.st_size, &csum) < 0) {
410 fprintf(stderr, "Failed to checksum file %s\n", location);
411 goto error;
412 }
413
414 size = 0;
415 namepadlen = 0;
416 for (i = 1; i <= nlinks; i++) {
417 if (name[0] == '/')
418 name++;
419 namesize = strlen(name) + 1;
420
421 /* data goes on last link, after any alignment padding */
422 if (i == nlinks)
423 size = buf.st_size;
424
425 if (dalign && size > dalign) {
426 namepadlen = padlen(offset + CPIO_HDR_LEN + namesize,
427 dalign);
428 if (namesize + namepadlen > PATH_MAX) {
429 fprintf(stderr,
430 "%s: best-effort alignment %u missed\n",
431 name, dalign);
432 namepadlen = 0;
433 }
434 }
435
436 len = dprintf(outfd, "%s%08X%08X%08lX%08lX%08X%08lX"
437 "%08lX%08X%08X%08X%08X%08X%08X",
438 do_csum ? "070702" : "070701", /* magic */
439 ino, /* ino */
440 mode, /* mode */
441 (long) uid, /* uid */
442 (long) gid, /* gid */
443 nlinks, /* nlink */
444 (long) mtime, /* mtime */
445 size, /* filesize */
446 3, /* major */
447 1, /* minor */
448 0, /* rmajor */
449 0, /* rminor */
450 namesize + namepadlen, /* namesize */
451 size ? csum : 0); /* chksum */
452 offset += len;
453
454 if (len != CPIO_HDR_LEN ||
455 push_buf(name, namesize) < 0 ||
456 push_pad(namepadlen ? namepadlen : padlen(offset, 4)) < 0)
457 goto error;
458
459 if (size) {
460 this_read = copy_file_range(file, NULL, outfd, NULL, size, 0);
461 if (this_read > 0) {
462 if (this_read > size)
463 goto error;
464 offset += this_read;
465 size -= this_read;
466 }
467 /* short or failed copy falls back to read/write... */
468 }
469
470 while (size) {
471 unsigned char filebuf[65536];
472 size_t this_size = MIN(size, sizeof(filebuf));
473
474 this_read = read(file, filebuf, this_size);
475 if (this_read <= 0 || this_read > this_size) {
476 fprintf(stderr, "Can not read %s file\n", location);
477 goto error;
478 }
479
480 if (write(outfd, filebuf, this_read) != this_read) {
481 fprintf(stderr, "writing filebuf failed\n");
482 goto error;
483 }
484 offset += this_read;
485 size -= this_read;
486 }
487 if (push_pad(padlen(offset, 4)) < 0)
488 goto error;
489
490 name += namesize;
491 }
492 ino++;
493 rc = 0;
494
495error:
496 if (file >= 0)
497 close(file);
498 return rc;
499}
500
501static char *cpio_replace_env(char *new_location)
502{
503 char expanded[PATH_MAX + 1];
504 char *start, *end, *var;
505
506 while ((start = strstr(new_location, "${")) &&
507 (end = strchr(start + 2, '}'))) {
508 *start = *end = 0;
509 var = getenv(start + 2);
510 snprintf(expanded, sizeof expanded, "%s%s%s",
511 new_location, var ? var : "", end + 1);
512 strcpy(new_location, expanded);
513 }
514
515 return new_location;
516}
517
518static int cpio_mkfile_line(const char *line)
519{
520 char name[PATH_MAX + 1];
521 char *dname = NULL; /* malloc'ed buffer for hard links */
522 char location[PATH_MAX + 1];
523 unsigned int mode;
524 int uid;
525 int gid;
526 int nlinks = 1;
527 int end = 0, dname_len = 0;
528 int rc = -1;
529
530 if (5 > sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX)
531 "s %o %d %d %n",
532 name, location, &mode, &uid, &gid, &end)) {
533 fprintf(stderr, "Unrecognized file format '%s'", line);
534 goto fail;
535 }
536 if (end && isgraph(line[end])) {
537 int len;
538 int nend;
539
540 dname = malloc(strlen(line));
541 if (!dname) {
542 fprintf (stderr, "out of memory (%d)\n", dname_len);
543 goto fail;
544 }
545
546 dname_len = strlen(name) + 1;
547 memcpy(dname, name, dname_len);
548
549 do {
550 nend = 0;
551 if (sscanf(line + end, "%" str(PATH_MAX) "s %n",
552 name, &nend) < 1)
553 break;
554 len = strlen(name) + 1;
555 memcpy(dname + dname_len, name, len);
556 dname_len += len;
557 nlinks++;
558 end += nend;
559 } while (isgraph(line[end]));
560 } else {
561 dname = name;
562 }
563 rc = cpio_mkfile(dname, cpio_replace_env(location),
564 mode, uid, gid, nlinks);
565 fail:
566 if (dname_len) free(dname);
567 return rc;
568}
569
570static void usage(const char *prog)
571{
572 fprintf(stderr, "Usage:\n"
573 "\t%s [-t <timestamp>] [-c] [-o <output_file>] [-a <data_align>] <cpio_list>\n"
574 "\n"
575 "<cpio_list> is a file containing newline separated entries that\n"
576 "describe the files to be included in the initramfs archive:\n"
577 "\n"
578 "# a comment\n"
579 "file <name> <location> <mode> <uid> <gid> [<hard links>]\n"
580 "dir <name> <mode> <uid> <gid>\n"
581 "nod <name> <mode> <uid> <gid> <dev_type> <maj> <min>\n"
582 "slink <name> <target> <mode> <uid> <gid>\n"
583 "pipe <name> <mode> <uid> <gid>\n"
584 "sock <name> <mode> <uid> <gid>\n"
585 "\n"
586 "<name> name of the file/dir/nod/etc in the archive\n"
587 "<location> location of the file in the current filesystem\n"
588 " expands shell variables quoted with ${}\n"
589 "<target> link target\n"
590 "<mode> mode/permissions of the file\n"
591 "<uid> user id (0=root)\n"
592 "<gid> group id (0=root)\n"
593 "<dev_type> device type (b=block, c=character)\n"
594 "<maj> major number of nod\n"
595 "<min> minor number of nod\n"
596 "<hard links> space separated list of other links to file\n"
597 "\n"
598 "example:\n"
599 "# A simple initramfs\n"
600 "dir /dev 0755 0 0\n"
601 "nod /dev/console 0600 0 0 c 5 1\n"
602 "dir /root 0700 0 0\n"
603 "dir /sbin 0755 0 0\n"
604 "file /sbin/kinit /usr/src/klibc/kinit/kinit 0755 0 0\n"
605 "\n"
606 "<timestamp> is time in seconds since Epoch that will be used\n"
607 "as mtime for symlinks, directories, regular and special files.\n"
608 "The default is to use the current time for all files, but\n"
609 "preserve modification time for regular files.\n"
610 "-c: calculate and store 32-bit checksums for file data.\n"
611 "<output_file>: write cpio to this file instead of stdout\n"
612 "<data_align>: attempt to align file data by zero-padding the\n"
613 "filename field up to data_align. Must be a multiple of 4.\n"
614 "Alignment is best-effort; PATH_MAX limits filename padding.\n",
615 prog);
616}
617
618static const struct file_handler file_handler_table[] = {
619 {
620 .type = "file",
621 .handler = cpio_mkfile_line,
622 }, {
623 .type = "nod",
624 .handler = cpio_mknod_line,
625 }, {
626 .type = "dir",
627 .handler = cpio_mkdir_line,
628 }, {
629 .type = "slink",
630 .handler = cpio_mkslink_line,
631 }, {
632 .type = "pipe",
633 .handler = cpio_mkpipe_line,
634 }, {
635 .type = "sock",
636 .handler = cpio_mksock_line,
637 }, {
638 .type = NULL,
639 .handler = NULL,
640 }
641};
642
643#define LINE_SIZE (2 * PATH_MAX + 50)
644
645int main (int argc, char *argv[])
646{
647 FILE *cpio_list;
648 char line[LINE_SIZE];
649 char *args, *type;
650 int ec = 0;
651 int line_nr = 0;
652 const char *filename;
653
654 default_mtime = time(NULL);
655 while (1) {
656 int opt = getopt(argc, argv, "t:cho:a:");
657 char *invalid;
658
659 if (opt == -1)
660 break;
661 switch (opt) {
662 case 't':
663 default_mtime = strtol(optarg, &invalid, 10);
664 if (!*optarg || *invalid) {
665 fprintf(stderr, "Invalid timestamp: %s\n",
666 optarg);
667 usage(argv[0]);
668 exit(1);
669 }
670 do_file_mtime = true;
671 break;
672 case 'c':
673 do_csum = true;
674 break;
675 case 'o':
676 outfd = open(optarg,
677 O_WRONLY | O_CREAT | O_LARGEFILE | O_TRUNC,
678 0600);
679 if (outfd < 0) {
680 fprintf(stderr, "failed to open %s\n", optarg);
681 usage(argv[0]);
682 exit(1);
683 }
684 break;
685 case 'a':
686 dalign = strtoul(optarg, &invalid, 10);
687 if (!*optarg || *invalid || (dalign & 3)) {
688 fprintf(stderr, "Invalid data_align: %s\n",
689 optarg);
690 usage(argv[0]);
691 exit(1);
692 }
693 break;
694 case 'h':
695 case '?':
696 usage(argv[0]);
697 exit(opt == 'h' ? 0 : 1);
698 }
699 }
700
701 /*
702 * Timestamps after 2106-02-07 06:28:15 UTC have an ascii hex time_t
703 * representation that exceeds 8 chars and breaks the cpio header
704 * specification. Negative timestamps similarly exceed 8 chars.
705 */
706 if (default_mtime > 0xffffffff || default_mtime < 0) {
707 fprintf(stderr, "ERROR: Timestamp out of range for cpio format\n");
708 exit(1);
709 }
710
711 if (argc - optind != 1) {
712 usage(argv[0]);
713 exit(1);
714 }
715 filename = argv[optind];
716 if (!strcmp(filename, "-"))
717 cpio_list = stdin;
718 else if (!(cpio_list = fopen(filename, "r"))) {
719 fprintf(stderr, "ERROR: unable to open '%s': %s\n\n",
720 filename, strerror(errno));
721 usage(argv[0]);
722 exit(1);
723 }
724
725 while (fgets(line, LINE_SIZE, cpio_list)) {
726 int type_idx;
727 size_t slen = strlen(line);
728
729 line_nr++;
730
731 if ('#' == *line) {
732 /* comment - skip to next line */
733 continue;
734 }
735
736 if (! (type = strtok(line, " \t"))) {
737 fprintf(stderr,
738 "ERROR: incorrect format, could not locate file type line %d: '%s'\n",
739 line_nr, line);
740 ec = -1;
741 break;
742 }
743
744 if ('\n' == *type) {
745 /* a blank line */
746 continue;
747 }
748
749 if (slen == strlen(type)) {
750 /* must be an empty line */
751 continue;
752 }
753
754 if (! (args = strtok(NULL, "\n"))) {
755 fprintf(stderr,
756 "ERROR: incorrect format, newline required line %d: '%s'\n",
757 line_nr, line);
758 ec = -1;
759 }
760
761 for (type_idx = 0; file_handler_table[type_idx].type; type_idx++) {
762 int rc;
763 if (! strcmp(line, file_handler_table[type_idx].type)) {
764 if ((rc = file_handler_table[type_idx].handler(args))) {
765 ec = rc;
766 fprintf(stderr, " line %d\n", line_nr);
767 }
768 break;
769 }
770 }
771
772 if (NULL == file_handler_table[type_idx].type) {
773 fprintf(stderr, "unknown file type line %d: '%s'\n",
774 line_nr, line);
775 }
776 }
777 if (ec == 0)
778 ec = cpio_trailer();
779
780 exit(ec);
781}