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