[thirdparty/linux.git] / usr / gen_init_cpio.c

// SPDX-License-Identifier: GPL-2.0
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>
#include <limits.h>

/*
 * Original work by Jeff Garzik
 *
 * External file lists, symlink, pipe and fifo support by Thayne Harbaugh
 * Hard link support by Luciano Rocha
 */

#define xstr(s) #s
#define str(s) xstr(s)
#define MIN(a, b) ((a) < (b) ? (a) : (b))

static unsigned int offset;
static unsigned int ino = 721;
static time_t default_mtime;
static bool do_csum = false;

struct file_handler {
	const char *type;
	int (*handler)(const char *line);
};

static void push_string(const char *name)
{
	unsigned int name_len = strlen(name) + 1;

	fputs(name, stdout);
	putchar(0);
	offset += name_len;
}

static void push_pad (void)
{
	while (offset & 3) {
		putchar(0);
		offset++;
	}
}

static void push_rest(const char *name)
{
	unsigned int name_len = strlen(name) + 1;
	unsigned int tmp_ofs;

	fputs(name, stdout);
	putchar(0);
	offset += name_len;

	tmp_ofs = name_len + 110;
	while (tmp_ofs & 3) {
		putchar(0);
		offset++;
		tmp_ofs++;
	}
}

static void push_hdr(const char *s)
{
	fputs(s, stdout);
	offset += 110;
}

static void cpio_trailer(void)
{
	char s[256];
	const char name[] = "TRAILER!!!";

	sprintf(s, "%s%08X%08X%08lX%08lX%08X%08lX"
	       "%08X%08X%08X%08X%08X%08X%08X",
		do_csum ? "070702" : "070701", /* magic */
		0,			/* ino */
		0,			/* mode */
		(long) 0,		/* uid */
		(long) 0,		/* gid */
		1,			/* nlink */
		(long) 0,		/* mtime */
		0,			/* filesize */
		0,			/* major */
		0,			/* minor */
		0,			/* rmajor */
		0,			/* rminor */
		(unsigned)strlen(name)+1, /* namesize */
		0);			/* chksum */
	push_hdr(s);
	push_rest(name);

	while (offset % 512) {
		putchar(0);
		offset++;
	}
}

static int cpio_mkslink(const char *name, const char *target,
			 unsigned int mode, uid_t uid, gid_t gid)
{
	char s[256];

	if (name[0] == '/')
		name++;
	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
	       "%08X%08X%08X%08X%08X%08X%08X",
		do_csum ? "070702" : "070701", /* magic */
		ino++,			/* ino */
		S_IFLNK | mode,		/* mode */
		(long) uid,		/* uid */
		(long) gid,		/* gid */
		1,			/* nlink */
		(long) default_mtime,	/* mtime */
		(unsigned)strlen(target)+1, /* filesize */
		3,			/* major */
		1,			/* minor */
		0,			/* rmajor */
		0,			/* rminor */
		(unsigned)strlen(name) + 1,/* namesize */
		0);			/* chksum */
	push_hdr(s);
	push_string(name);
	push_pad();
	push_string(target);
	push_pad();
	return 0;
}

static int cpio_mkslink_line(const char *line)
{
	char name[PATH_MAX + 1];
	char target[PATH_MAX + 1];
	unsigned int mode;
	int uid;
	int gid;
	int rc = -1;

	if (5 != sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX) "s %o %d %d", name, target, &mode, &uid, &gid)) {
		fprintf(stderr, "Unrecognized dir format '%s'", line);
		goto fail;
	}
	rc = cpio_mkslink(name, target, mode, uid, gid);
 fail:
	return rc;
}

static int cpio_mkgeneric(const char *name, unsigned int mode,
		       uid_t uid, gid_t gid)
{
	char s[256];

	if (name[0] == '/')
		name++;
	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
	       "%08X%08X%08X%08X%08X%08X%08X",
		do_csum ? "070702" : "070701", /* magic */
		ino++,			/* ino */
		mode,			/* mode */
		(long) uid,		/* uid */
		(long) gid,		/* gid */
		2,			/* nlink */
		(long) default_mtime,	/* mtime */
		0,			/* filesize */
		3,			/* major */
		1,			/* minor */
		0,			/* rmajor */
		0,			/* rminor */
		(unsigned)strlen(name) + 1,/* namesize */
		0);			/* chksum */
	push_hdr(s);
	push_rest(name);
	return 0;
}

enum generic_types {
	GT_DIR,
	GT_PIPE,
	GT_SOCK
};

struct generic_type {
	const char *type;
	mode_t mode;
};

static const struct generic_type generic_type_table[] = {
	[GT_DIR] = {
		.type = "dir",
		.mode = S_IFDIR
	},
	[GT_PIPE] = {
		.type = "pipe",
		.mode = S_IFIFO
	},
	[GT_SOCK] = {
		.type = "sock",
		.mode = S_IFSOCK
	}
};

static int cpio_mkgeneric_line(const char *line, enum generic_types gt)
{
	char name[PATH_MAX + 1];
	unsigned int mode;
	int uid;
	int gid;
	int rc = -1;

	if (4 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d", name, &mode, &uid, &gid)) {
		fprintf(stderr, "Unrecognized %s format '%s'",
			line, generic_type_table[gt].type);
		goto fail;
	}
	mode |= generic_type_table[gt].mode;
	rc = cpio_mkgeneric(name, mode, uid, gid);
 fail:
	return rc;
}

static int cpio_mkdir_line(const char *line)
{
	return cpio_mkgeneric_line(line, GT_DIR);
}

static int cpio_mkpipe_line(const char *line)
{
	return cpio_mkgeneric_line(line, GT_PIPE);
}

static int cpio_mksock_line(const char *line)
{
	return cpio_mkgeneric_line(line, GT_SOCK);
}

static int cpio_mknod(const char *name, unsigned int mode,
		       uid_t uid, gid_t gid, char dev_type,
		       unsigned int maj, unsigned int min)
{
	char s[256];

	if (dev_type == 'b')
		mode |= S_IFBLK;
	else
		mode |= S_IFCHR;

	if (name[0] == '/')
		name++;
	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
	       "%08X%08X%08X%08X%08X%08X%08X",
		do_csum ? "070702" : "070701", /* magic */
		ino++,			/* ino */
		mode,			/* mode */
		(long) uid,		/* uid */
		(long) gid,		/* gid */
		1,			/* nlink */
		(long) default_mtime,	/* mtime */
		0,			/* filesize */
		3,			/* major */
		1,			/* minor */
		maj,			/* rmajor */
		min,			/* rminor */
		(unsigned)strlen(name) + 1,/* namesize */
		0);			/* chksum */
	push_hdr(s);
	push_rest(name);
	return 0;
}

static int cpio_mknod_line(const char *line)
{
	char name[PATH_MAX + 1];
	unsigned int mode;
	int uid;
	int gid;
	char dev_type;
	unsigned int maj;
	unsigned int min;
	int rc = -1;

	if (7 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d %c %u %u",
			 name, &mode, &uid, &gid, &dev_type, &maj, &min)) {
		fprintf(stderr, "Unrecognized nod format '%s'", line);
		goto fail;
	}
	rc = cpio_mknod(name, mode, uid, gid, dev_type, maj, min);
 fail:
	return rc;
}

static int cpio_mkfile_csum(int fd, unsigned long size, uint32_t *csum)
{
	while (size) {
		unsigned char filebuf[65536];
		ssize_t this_read;
		size_t i, this_size = MIN(size, sizeof(filebuf));

		this_read = read(fd, filebuf, this_size);
		if (this_read <= 0 || this_read > this_size)
			return -1;

		for (i = 0; i < this_read; i++)
			*csum += filebuf[i];

		size -= this_read;
	}
	/* seek back to the start for data segment I/O */
	if (lseek(fd, 0, SEEK_SET) < 0)
		return -1;

	return 0;
}

static int cpio_mkfile(const char *name, const char *location,
			unsigned int mode, uid_t uid, gid_t gid,
			unsigned int nlinks)
{
	char s[256];
	struct stat buf;
	unsigned long size;
	int file;
	int retval;
	int rc = -1;
	int namesize;
	unsigned int i;
	uint32_t csum = 0;

	mode |= S_IFREG;

	file = open (location, O_RDONLY);
	if (file < 0) {
		fprintf (stderr, "File %s could not be opened for reading\n", location);
		goto error;
	}

	retval = fstat(file, &buf);
	if (retval) {
		fprintf(stderr, "File %s could not be stat()'ed\n", location);
		goto error;
	}

	if (buf.st_mtime > 0xffffffff) {
		fprintf(stderr, "%s: Timestamp exceeds maximum cpio timestamp, clipping.\n",
			location);
		buf.st_mtime = 0xffffffff;
	}

	if (buf.st_mtime < 0) {
		fprintf(stderr, "%s: Timestamp negative, clipping.\n",
			location);
		buf.st_mtime = 0;
	}

	if (buf.st_size > 0xffffffff) {
		fprintf(stderr, "%s: Size exceeds maximum cpio file size\n",
			location);
		goto error;
	}

	if (do_csum && cpio_mkfile_csum(file, buf.st_size, &csum) < 0) {
		fprintf(stderr, "Failed to checksum file %s\n", location);
		goto error;
	}

	size = 0;
	for (i = 1; i <= nlinks; i++) {
		/* data goes on last link */
		if (i == nlinks)
			size = buf.st_size;

		if (name[0] == '/')
			name++;
		namesize = strlen(name) + 1;
		sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
		       "%08lX%08X%08X%08X%08X%08X%08X",
			do_csum ? "070702" : "070701", /* magic */
			ino,			/* ino */
			mode,			/* mode */
			(long) uid,		/* uid */
			(long) gid,		/* gid */
			nlinks,			/* nlink */
			(long) buf.st_mtime,	/* mtime */
			size,			/* filesize */
			3,			/* major */
			1,			/* minor */
			0,			/* rmajor */
			0,			/* rminor */
			namesize,		/* namesize */
			size ? csum : 0);	/* chksum */
		push_hdr(s);
		push_string(name);
		push_pad();

		while (size) {
			unsigned char filebuf[65536];
			ssize_t this_read;
			size_t this_size = MIN(size, sizeof(filebuf));

			this_read = read(file, filebuf, this_size);
			if (this_read <= 0 || this_read > this_size) {
				fprintf(stderr, "Can not read %s file\n", location);
				goto error;
			}

			if (fwrite(filebuf, this_read, 1, stdout) != 1) {
				fprintf(stderr, "writing filebuf failed\n");
				goto error;
			}
			offset += this_read;
			size -= this_read;
		}
		push_pad();

		name += namesize;
	}
	ino++;
	rc = 0;

error:
	if (file >= 0)
		close(file);
	return rc;
}

static char *cpio_replace_env(char *new_location)
{
	char expanded[PATH_MAX + 1];
	char *start, *end, *var;

	while ((start = strstr(new_location, "${")) &&
	       (end = strchr(start + 2, '}'))) {
		*start = *end = 0;
		var = getenv(start + 2);
		snprintf(expanded, sizeof expanded, "%s%s%s",
			 new_location, var ? var : "", end + 1);
		strcpy(new_location, expanded);
	}

	return new_location;
}

static int cpio_mkfile_line(const char *line)
{
	char name[PATH_MAX + 1];
	char *dname = NULL; /* malloc'ed buffer for hard links */
	char location[PATH_MAX + 1];
	unsigned int mode;
	int uid;
	int gid;
	int nlinks = 1;
	int end = 0, dname_len = 0;
	int rc = -1;

	if (5 > sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX)
				"s %o %d %d %n",
				name, location, &mode, &uid, &gid, &end)) {
		fprintf(stderr, "Unrecognized file format '%s'", line);
		goto fail;
	}
	if (end && isgraph(line[end])) {
		int len;
		int nend;

		dname = malloc(strlen(line));
		if (!dname) {
			fprintf (stderr, "out of memory (%d)\n", dname_len);
			goto fail;
		}

		dname_len = strlen(name) + 1;
		memcpy(dname, name, dname_len);

		do {
			nend = 0;
			if (sscanf(line + end, "%" str(PATH_MAX) "s %n",
					name, &nend) < 1)
				break;
			len = strlen(name) + 1;
			memcpy(dname + dname_len, name, len);
			dname_len += len;
			nlinks++;
			end += nend;
		} while (isgraph(line[end]));
	} else {
		dname = name;
	}
	rc = cpio_mkfile(dname, cpio_replace_env(location),
	                 mode, uid, gid, nlinks);
 fail:
	if (dname_len) free(dname);
	return rc;
}

static void usage(const char *prog)
{
	fprintf(stderr, "Usage:\n"
		"\t%s [-t <timestamp>] [-c] <cpio_list>\n"
		"\n"
		"<cpio_list> is a file containing newline separated entries that\n"
		"describe the files to be included in the initramfs archive:\n"
		"\n"
		"# a comment\n"
		"file <name> <location> <mode> <uid> <gid> [<hard links>]\n"
		"dir <name> <mode> <uid> <gid>\n"
		"nod <name> <mode> <uid> <gid> <dev_type> <maj> <min>\n"
		"slink <name> <target> <mode> <uid> <gid>\n"
		"pipe <name> <mode> <uid> <gid>\n"
		"sock <name> <mode> <uid> <gid>\n"
		"\n"
		"<name>       name of the file/dir/nod/etc in the archive\n"
		"<location>   location of the file in the current filesystem\n"
		"             expands shell variables quoted with ${}\n"
		"<target>     link target\n"
		"<mode>       mode/permissions of the file\n"
		"<uid>        user id (0=root)\n"
		"<gid>        group id (0=root)\n"
		"<dev_type>   device type (b=block, c=character)\n"
		"<maj>        major number of nod\n"
		"<min>        minor number of nod\n"
		"<hard links> space separated list of other links to file\n"
		"\n"
		"example:\n"
		"# A simple initramfs\n"
		"dir /dev 0755 0 0\n"
		"nod /dev/console 0600 0 0 c 5 1\n"
		"dir /root 0700 0 0\n"
		"dir /sbin 0755 0 0\n"
		"file /sbin/kinit /usr/src/klibc/kinit/kinit 0755 0 0\n"
		"\n"
		"<timestamp> is time in seconds since Epoch that will be used\n"
		"as mtime for symlinks, special files and directories. The default\n"
		"is to use the current time for these entries.\n"
		"-c: calculate and store 32-bit checksums for file data.\n",
		prog);
}

static const struct file_handler file_handler_table[] = {
	{
		.type    = "file",
		.handler = cpio_mkfile_line,
	}, {
		.type    = "nod",
		.handler = cpio_mknod_line,
	}, {
		.type    = "dir",
		.handler = cpio_mkdir_line,
	}, {
		.type    = "slink",
		.handler = cpio_mkslink_line,
	}, {
		.type    = "pipe",
		.handler = cpio_mkpipe_line,
	}, {
		.type    = "sock",
		.handler = cpio_mksock_line,
	}, {
		.type    = NULL,
		.handler = NULL,
	}
};

#define LINE_SIZE (2 * PATH_MAX + 50)

int main (int argc, char *argv[])
{
	FILE *cpio_list;
	char line[LINE_SIZE];
	char *args, *type;
	int ec = 0;
	int line_nr = 0;
	const char *filename;

	default_mtime = time(NULL);
	while (1) {
		int opt = getopt(argc, argv, "t:ch");
		char *invalid;

		if (opt == -1)
			break;
		switch (opt) {
		case 't':
			default_mtime = strtol(optarg, &invalid, 10);
			if (!*optarg || *invalid) {
				fprintf(stderr, "Invalid timestamp: %s\n",
						optarg);
				usage(argv[0]);
				exit(1);
			}
			break;
		case 'c':
			do_csum = true;
			break;
		case 'h':
		case '?':
			usage(argv[0]);
			exit(opt == 'h' ? 0 : 1);
		}
	}

	/*
	 * Timestamps after 2106-02-07 06:28:15 UTC have an ascii hex time_t
	 * representation that exceeds 8 chars and breaks the cpio header
	 * specification. Negative timestamps similarly exceed 8 chars.
	 */
	if (default_mtime > 0xffffffff || default_mtime < 0) {
		fprintf(stderr, "ERROR: Timestamp out of range for cpio format\n");
		exit(1);
	}

	if (argc - optind != 1) {
		usage(argv[0]);
		exit(1);
	}
	filename = argv[optind];
	if (!strcmp(filename, "-"))
		cpio_list = stdin;
	else if (!(cpio_list = fopen(filename, "r"))) {
		fprintf(stderr, "ERROR: unable to open '%s': %s\n\n",
			filename, strerror(errno));
		usage(argv[0]);
		exit(1);
	}

	while (fgets(line, LINE_SIZE, cpio_list)) {
		int type_idx;
		size_t slen = strlen(line);

		line_nr++;

		if ('#' == *line) {
			/* comment - skip to next line */
			continue;
		}

		if (! (type = strtok(line, " \t"))) {
			fprintf(stderr,
				"ERROR: incorrect format, could not locate file type line %d: '%s'\n",
				line_nr, line);
			ec = -1;
			break;
		}

		if ('\n' == *type) {
			/* a blank line */
			continue;
		}

		if (slen == strlen(type)) {
			/* must be an empty line */
			continue;
		}

		if (! (args = strtok(NULL, "\n"))) {
			fprintf(stderr,
				"ERROR: incorrect format, newline required line %d: '%s'\n",
				line_nr, line);
			ec = -1;
		}

		for (type_idx = 0; file_handler_table[type_idx].type; type_idx++) {
			int rc;
			if (! strcmp(line, file_handler_table[type_idx].type)) {
				if ((rc = file_handler_table[type_idx].handler(args))) {
					ec = rc;
					fprintf(stderr, " line %d\n", line_nr);
				}
				break;
			}
		}

		if (NULL == file_handler_table[type_idx].type) {
			fprintf(stderr, "unknown file type line %d: '%s'\n",
				line_nr, line);
		}
	}
	if (ec == 0)
		cpio_trailer();

	exit(ec);
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	#include <stdio.h>
1da177e4 LT	3	#include <stdlib.h>
ea804871 DD	4	#include <stdint.h>
ea804871 DD	5	#include <stdbool.h>
1da177e4 LT	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
24fa5096	20	* Hard link support by Luciano Rocha
1da177e4 LT	21	*/
	22
	23	#define xstr(s) #s
	24	#define str(s) xstr(s)
3a2699cf	25	#define MIN(a, b) ((a) < (b) ? (a) : (b))
1da177e4 LT	26
	27	static unsigned int offset;
	28	static unsigned int ino = 721;
a8b8017c	29	static time_t default_mtime;
ea804871	30	static bool do_csum = false;
1da177e4 LT	31
	32	struct file_handler {
	33	const char *type;
	34	int (handler)(const char line);
	35	};
	36
	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
	46	static void push_pad (void)
	47	{
	48	while (offset & 3) {
	49	putchar(0);
	50	offset++;
	51	}
	52	}
	53
	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
	71	static void push_hdr(const char *s)
	72	{
	73	fputs(s, stdout);
	74	offset += 110;
	75	}
	76
	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",
ea804871	84	do_csum ? "070702" : "070701", /* magic */
1da177e4 LT	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
	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];
1da177e4	111
43f901fb TC	112	if (name[0] == '/')
43f901fb TC	113	name++;
1da177e4 LT	114	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
1da177e4 LT	115	"%08X%08X%08X%08X%08X%08X%08X",
ea804871	116	do_csum ? "070702" : "070701", /* magic */
1da177e4 LT	117	ino++, /* ino */
	118	S_IFLNK \| mode, /* mode */
	119	(long) uid, /* uid */
	120	(long) gid, /* gid */
	121	1, /* nlink */
a8b8017c	122	(long) default_mtime, /* mtime */
1da177e4 LT	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
	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
	156	static int cpio_mkgeneric(const char *name, unsigned int mode,
	157	uid_t uid, gid_t gid)
	158	{
	159	char s[256];
1da177e4	160
43f901fb TC	161	if (name[0] == '/')
43f901fb TC	162	name++;
1da177e4 LT	163	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
1da177e4 LT	164	"%08X%08X%08X%08X%08X%08X%08X",
ea804871	165	do_csum ? "070702" : "070701", /* magic */
1da177e4 LT	166	ino++, /* ino */
	167	mode, /* mode */
	168	(long) uid, /* uid */
	169	(long) gid, /* gid */
	170	2, /* nlink */
a8b8017c	171	(long) default_mtime, /* mtime */
1da177e4 LT	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
3510c5cf	195	static const struct generic_type generic_type_table[] = {
1da177e4 LT	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
	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
	229	static int cpio_mkdir_line(const char *line)
	230	{
	231	return cpio_mkgeneric_line(line, GT_DIR);
	232	}
	233
	234	static int cpio_mkpipe_line(const char *line)
	235	{
	236	return cpio_mkgeneric_line(line, GT_PIPE);
	237	}
	238
	239	static int cpio_mksock_line(const char *line)
	240	{
	241	return cpio_mkgeneric_line(line, GT_SOCK);
	242	}
	243
	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];
1da177e4 LT	249
	250	if (dev_type == 'b')
	251	mode \|= S_IFBLK;
	252	else
	253	mode \|= S_IFCHR;
	254
43f901fb TC	255	if (name[0] == '/')
43f901fb TC	256	name++;
1da177e4 LT	257	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
1da177e4 LT	258	"%08X%08X%08X%08X%08X%08X%08X",
ea804871	259	do_csum ? "070702" : "070701", /* magic */
1da177e4 LT	260	ino++, /* ino */
	261	mode, /* mode */
	262	(long) uid, /* uid */
	263	(long) gid, /* gid */
	264	1, /* nlink */
a8b8017c	265	(long) default_mtime, /* mtime */
1da177e4 LT	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
	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
ea804871 DD	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
1da177e4	322	static int cpio_mkfile(const char name, const char location,
24fa5096 LR	323	unsigned int mode, uid_t uid, gid_t gid,
24fa5096 LR	324	unsigned int nlinks)
1da177e4 LT	325	{
1da177e4 LT	326	char s[256];
1da177e4	327	struct stat buf;
3a2699cf	328	unsigned long size;
462cd772	329	int file;
1da177e4 LT	330	int retval;
1da177e4 LT	331	int rc = -1;
24fa5096	332	int namesize;
20f1de65	333	unsigned int i;
ea804871	334	uint32_t csum = 0;
1da177e4 LT	335
	336	mode \|= S_IFREG;
	337
1da177e4 LT	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
a3c888fc	344	retval = fstat(file, &buf);
96aebafa	345	if (retval) {
a3c888fc	346	fprintf(stderr, "File %s could not be stat()'ed\n", location);
96aebafa JJ	347	goto error;
	348	}
	349
4c9d410f NS	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
5efb685b BG	356	if (buf.st_mtime < 0) {
	357	fprintf(stderr, "%s: Timestamp negative, clipping.\n",
	358	location);
	359	buf.st_mtime = 0;
	360	}
	361
3a2699cf DD	362	if (buf.st_size > 0xffffffff) {
	363	fprintf(stderr, "%s: Size exceeds maximum cpio file size\n",
	364	location);
1da177e4 LT	365	goto error;
	366	}
	367
ea804871 DD	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
24fa5096 LR	373	size = 0;
	374	for (i = 1; i <= nlinks; i++) {
	375	/* data goes on last link */
3a2699cf DD	376	if (i == nlinks)
3a2699cf DD	377	size = buf.st_size;
24fa5096	378
43f901fb TC	379	if (name[0] == '/')
43f901fb TC	380	name++;
24fa5096 LR	381	namesize = strlen(name) + 1;
	382	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
	383	"%08lX%08X%08X%08X%08X%08X%08X",
ea804871	384	do_csum ? "070702" : "070701", /* magic */
24fa5096 LR	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 */
ea804871	397	size ? csum : 0); /* chksum */
24fa5096 LR	398	push_hdr(s);
	399	push_string(name);
	400	push_pad();
	401
3a2699cf DD	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) {
6d87fea4 MF	414	fprintf(stderr, "writing filebuf failed\n");
	415	goto error;
	416	}
3a2699cf DD	417	offset += this_read;
3a2699cf DD	418	size -= this_read;
24fa5096	419	}
3a2699cf	420	push_pad();
24fa5096 LR	421
	422	name += namesize;
	423	}
	424	ino++;
1da177e4	425	rc = 0;
3a2699cf	426
1da177e4	427	error:
3a2699cf DD	428	if (file >= 0)
3a2699cf DD	429	close(file);
1da177e4 LT	430	return rc;
	431	}
	432
3b1ec9fb SG	433	static char cpio_replace_env(char new_location)
3b1ec9fb SG	434	{
20f1de65	435	char expanded[PATH_MAX + 1];
c725ee54 MN	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);
20f1de65 KC	445	}
	446
	447	return new_location;
3b1ec9fb SG	448	}
3b1ec9fb SG	449
1da177e4 LT	450	static int cpio_mkfile_line(const char *line)
	451	{
	452	char name[PATH_MAX + 1];
24fa5096	453	char dname = NULL; / malloc'ed buffer for hard links */
1da177e4 LT	454	char location[PATH_MAX + 1];
	455	unsigned int mode;
	456	int uid;
	457	int gid;
24fa5096 LR	458	int nlinks = 1;
24fa5096 LR	459	int end = 0, dname_len = 0;
1da177e4 LT	460	int rc = -1;
1da177e4 LT	461
24fa5096 LR	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)) {
1da177e4 LT	465	fprintf(stderr, "Unrecognized file format '%s'", line);
	466	goto fail;
	467	}
24fa5096 LR	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	}
3b1ec9fb SG	495	rc = cpio_mkfile(dname, cpio_replace_env(location),
3b1ec9fb SG	496	mode, uid, gid, nlinks);
1da177e4	497	fail:
24fa5096	498	if (dname_len) free(dname);
1da177e4 LT	499	return rc;
	500	}
	501
5c725138	502	static void usage(const char *prog)
1da177e4 LT	503	{
1da177e4 LT	504	fprintf(stderr, "Usage:\n"
ea804871	505	"\t%s [-t <timestamp>] [-c] <cpio_list>\n"
1da177e4 LT	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"
24fa5096	511	"file <name> <location> <mode> <uid> <gid> [<hard links>]\n"
1da177e4 LT	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"
24fa5096 LR	518	"<name> name of the file/dir/nod/etc in the archive\n"
24fa5096 LR	519	"<location> location of the file in the current filesystem\n"
3b1ec9fb	520	" expands shell variables quoted with ${}\n"
24fa5096 LR	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"
1da177e4 LT	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"
a8b8017c MM	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"
ea804871 DD	540	"is to use the current time for these entries.\n"
ea804871 DD	541	"-c: calculate and store 32-bit checksums for file data.\n",
1da177e4 LT	542	prog);
	543	}
	544
3510c5cf	545	static const struct file_handler file_handler_table[] = {
1da177e4 LT	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
	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;
a8b8017c MM	579	const char *filename;
	580
	581	default_mtime = time(NULL);
	582	while (1) {
ea804871	583	int opt = getopt(argc, argv, "t:ch");
a8b8017c MM	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;
ea804871 DD	598	case 'c':
	599	do_csum = true;
	600	break;
a8b8017c MM	601	case 'h':
	602	case '?':
	603	usage(argv[0]);
	604	exit(opt == 'h' ? 0 : 1);
	605	}
	606	}
1da177e4	607
4c9d410f NS	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
5efb685b	611	* specification. Negative timestamps similarly exceed 8 chars.
4c9d410f	612	*/
5efb685b BG	613	if (default_mtime > 0xffffffff \|\| default_mtime < 0) {
5efb685b BG	614	fprintf(stderr, "ERROR: Timestamp out of range for cpio format\n");
4c9d410f NS	615	exit(1);
	616	}
	617
a8b8017c	618	if (argc - optind != 1) {
1da177e4 LT	619	usage(argv[0]);
	620	exit(1);
	621	}
a8b8017c MM	622	filename = argv[optind];
a8b8017c MM	623	if (!strcmp(filename, "-"))
f2434ec1	624	cpio_list = stdin;
a8b8017c	625	else if (!(cpio_list = fopen(filename, "r"))) {
1da177e4	626	fprintf(stderr, "ERROR: unable to open '%s': %s\n\n",
a8b8017c	627	filename, strerror(errno));
1da177e4 LT	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;
aa1e816f	648	break;
1da177e4 LT	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	}
aa1e816f JJ	684	if (ec == 0)
aa1e816f JJ	685	cpio_trailer();
1da177e4 LT	686
	687	exit(ec);
	688	}