[linux.git] / usr / gen_init_cpio.c

#include <stdio.h>
#include <stdlib.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)

static unsigned int offset;
static unsigned int ino = 721;
static time_t default_mtime;

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",
		"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",
		"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",
		"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 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",
		"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(const char *name, const char *location,
			unsigned int mode, uid_t uid, gid_t gid,
			unsigned int nlinks)
{
	char s[256];
	char *filebuf = NULL;
	struct stat buf;
	long size;
	int file = -1;
	int retval;
	int rc = -1;
	int namesize;
	unsigned int i;

	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;
	}

	filebuf = malloc(buf.st_size);
	if (!filebuf) {
		fprintf (stderr, "out of memory\n");
		goto error;
	}

	retval = read (file, filebuf, buf.st_size);
	if (retval < 0) {
		fprintf (stderr, "Can not read %s file\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",
			"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 */
			0);			/* chksum */
		push_hdr(s);
		push_string(name);
		push_pad();

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

		name += namesize;
	}
	ino++;
	rc = 0;
	
error:
	if (filebuf) free(filebuf);
	if (file >= 0) close(file);
	return rc;
}

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

	for (start = NULL; (start = strstr(new_location, "${")); ) {
		end = strchr(start, '}');
		if (start < end) {
			*env_var = *expanded = '\0';
			strncat(env_var, start + 2, end - start - 2);
			strncat(expanded, new_location, start - new_location);
			strncat(expanded, getenv(env_var),
				PATH_MAX - strlen(expanded));
			strncat(expanded, end + 1,
				PATH_MAX - strlen(expanded));
			strncpy(new_location, expanded, PATH_MAX);
			new_location[PATH_MAX] = 0;
		} else
			break;
	}

	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>] <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",
		prog);
}

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:h");
		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 'h':
		case '?':
			usage(argv[0]);
			exit(opt == 'h' ? 0 : 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
1da177e4 LT	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
24fa5096	17	* Hard link support by Luciano Rocha
1da177e4 LT	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;
a8b8017c	25	static time_t default_mtime;
1da177e4 LT	26
	27	struct file_handler {
	28	const char *type;
	29	int (handler)(const char line);
	30	};
	31
	32	static void push_string(const char *name)
	33	{
	34	unsigned int name_len = strlen(name) + 1;
	35
	36	fputs(name, stdout);
	37	putchar(0);
	38	offset += name_len;
	39	}
	40
	41	static void push_pad (void)
	42	{
	43	while (offset & 3) {
	44	putchar(0);
	45	offset++;
	46	}
	47	}
	48
	49	static void push_rest(const char *name)
	50	{
	51	unsigned int name_len = strlen(name) + 1;
	52	unsigned int tmp_ofs;
	53
	54	fputs(name, stdout);
	55	putchar(0);
	56	offset += name_len;
	57
	58	tmp_ofs = name_len + 110;
	59	while (tmp_ofs & 3) {
	60	putchar(0);
	61	offset++;
	62	tmp_ofs++;
	63	}
	64	}
	65
	66	static void push_hdr(const char *s)
	67	{
	68	fputs(s, stdout);
	69	offset += 110;
	70	}
	71
	72	static void cpio_trailer(void)
	73	{
	74	char s[256];
	75	const char name[] = "TRAILER!!!";
	76
	77	sprintf(s, "%s%08X%08X%08lX%08lX%08X%08lX"
	78	"%08X%08X%08X%08X%08X%08X%08X",
	79	"070701", /* magic */
	80	0, /* ino */
	81	0, /* mode */
	82	(long) 0, /* uid */
	83	(long) 0, /* gid */
	84	1, /* nlink */
	85	(long) 0, /* mtime */
	86	0, /* filesize */
	87	0, /* major */
	88	0, /* minor */
	89	0, /* rmajor */
90	0, /* rminor */
91	(unsigned)strlen(name)+1, /* namesize */
92	0); /* chksum */
93	push_hdr(s);
94	push_rest(name);
95
96	while (offset % 512) {
97	putchar(0);
98	offset++;
99	}
100	}
101
102	static int cpio_mkslink(const char name, const char target,
103	unsigned int mode, uid_t uid, gid_t gid)
104	{
105	char s[256];
1da177e4	106
43f901fb TC	107	if (name[0] == '/')
43f901fb TC	108	name++;
1da177e4 LT	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 */
a8b8017c	117	(long) default_mtime, /* mtime */
1da177e4 LT	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];
1da177e4	155
43f901fb TC	156	if (name[0] == '/')
43f901fb TC	157	name++;
1da177e4 LT	158	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
	159	"%08X%08X%08X%08X%08X%08X%08X",
	160	"070701", /* magic */
	161	ino++, /* ino */
	162	mode, /* mode */
	163	(long) uid, /* uid */
	164	(long) gid, /* gid */
	165	2, /* nlink */
a8b8017c	166	(long) default_mtime, /* mtime */
1da177e4 LT	167	0, /* filesize */
	168	3, /* major */
	169	1, /* minor */
	170	0, /* rmajor */
	171	0, /* rminor */
	172	(unsigned)strlen(name) + 1,/* namesize */
	173	0); /* chksum */
	174	push_hdr(s);
	175	push_rest(name);
	176	return 0;
	177	}
	178
	179	enum generic_types {
	180	GT_DIR,
	181	GT_PIPE,
	182	GT_SOCK
	183	};
	184
	185	struct generic_type {
	186	const char *type;
	187	mode_t mode;
	188	};
	189
	190	static struct generic_type generic_type_table[] = {
	191	[GT_DIR] = {
	192	.type = "dir",
	193	.mode = S_IFDIR
	194	},
	195	[GT_PIPE] = {
	196	.type = "pipe",
	197	.mode = S_IFIFO
	198	},
	199	[GT_SOCK] = {
	200	.type = "sock",
	201	.mode = S_IFSOCK
	202	}
	203	};
	204
	205	static int cpio_mkgeneric_line(const char *line, enum generic_types gt)
	206	{
	207	char name[PATH_MAX + 1];
	208	unsigned int mode;
	209	int uid;
	210	int gid;
	211	int rc = -1;
	212
	213	if (4 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d", name, &mode, &uid, &gid)) {
	214	fprintf(stderr, "Unrecognized %s format '%s'",
	215	line, generic_type_table[gt].type);
	216	goto fail;
	217	}
	218	mode \|= generic_type_table[gt].mode;
	219	rc = cpio_mkgeneric(name, mode, uid, gid);
	220	fail:
	221	return rc;
	222	}
	223
	224	static int cpio_mkdir_line(const char *line)
	225	{
	226	return cpio_mkgeneric_line(line, GT_DIR);
	227	}
	228
	229	static int cpio_mkpipe_line(const char *line)
	230	{
231	return cpio_mkgeneric_line(line, GT_PIPE);
232	}
233
234	static int cpio_mksock_line(const char *line)
235	{
236	return cpio_mkgeneric_line(line, GT_SOCK);
237	}
238
239	static int cpio_mknod(const char *name, unsigned int mode,
240	uid_t uid, gid_t gid, char dev_type,
241	unsigned int maj, unsigned int min)
242	{
243	char s[256];
1da177e4 LT	244
	245	if (dev_type == 'b')
	246	mode \|= S_IFBLK;
	247	else
	248	mode \|= S_IFCHR;
	249
43f901fb TC	250	if (name[0] == '/')
43f901fb TC	251	name++;
1da177e4 LT	252	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
	253	"%08X%08X%08X%08X%08X%08X%08X",
	254	"070701", /* magic */
	255	ino++, /* ino */
	256	mode, /* mode */
	257	(long) uid, /* uid */
	258	(long) gid, /* gid */
	259	1, /* nlink */
a8b8017c	260	(long) default_mtime, /* mtime */
1da177e4 LT	261	0, /* filesize */
	262	3, /* major */
	263	1, /* minor */
	264	maj, /* rmajor */
	265	min, /* rminor */
	266	(unsigned)strlen(name) + 1,/* namesize */
	267	0); /* chksum */
	268	push_hdr(s);
	269	push_rest(name);
	270	return 0;
	271	}
	272
	273	static int cpio_mknod_line(const char *line)
	274	{
	275	char name[PATH_MAX + 1];
	276	unsigned int mode;
	277	int uid;
	278	int gid;
	279	char dev_type;
	280	unsigned int maj;
	281	unsigned int min;
	282	int rc = -1;
	283
	284	if (7 != sscanf(line, "%" str(PATH_MAX) "s %o %d %d %c %u %u",
	285	name, &mode, &uid, &gid, &dev_type, &maj, &min)) {
	286	fprintf(stderr, "Unrecognized nod format '%s'", line);
	287	goto fail;
	288	}
	289	rc = cpio_mknod(name, mode, uid, gid, dev_type, maj, min);
	290	fail:
	291	return rc;
	292	}
	293
1da177e4	294	static int cpio_mkfile(const char name, const char location,
24fa5096 LR	295	unsigned int mode, uid_t uid, gid_t gid,
24fa5096 LR	296	unsigned int nlinks)
1da177e4 LT	297	{
	298	char s[256];
	299	char *filebuf = NULL;
	300	struct stat buf;
24fa5096	301	long size;
1da177e4 LT	302	int file = -1;
	303	int retval;
	304	int rc = -1;
24fa5096	305	int namesize;
20f1de65	306	unsigned int i;
1da177e4 LT	307
	308	mode \|= S_IFREG;
	309
1da177e4 LT	310	file = open (location, O_RDONLY);
	311	if (file < 0) {
	312	fprintf (stderr, "File %s could not be opened for reading\n", location);
	313	goto error;
	314	}
	315
a3c888fc	316	retval = fstat(file, &buf);
96aebafa	317	if (retval) {
a3c888fc	318	fprintf(stderr, "File %s could not be stat()'ed\n", location);
96aebafa JJ	319	goto error;
	320	}
	321
1da177e4 LT	322	filebuf = malloc(buf.st_size);
	323	if (!filebuf) {
	324	fprintf (stderr, "out of memory\n");
	325	goto error;
	326	}
	327
	328	retval = read (file, filebuf, buf.st_size);
	329	if (retval < 0) {
	330	fprintf (stderr, "Can not read %s file\n", location);
	331	goto error;
	332	}
	333
24fa5096 LR	334	size = 0;
	335	for (i = 1; i <= nlinks; i++) {
	336	/* data goes on last link */
	337	if (i == nlinks) size = buf.st_size;
	338
43f901fb TC	339	if (name[0] == '/')
43f901fb TC	340	name++;
24fa5096 LR	341	namesize = strlen(name) + 1;
	342	sprintf(s,"%s%08X%08X%08lX%08lX%08X%08lX"
	343	"%08lX%08X%08X%08X%08X%08X%08X",
	344	"070701", /* magic */
	345	ino, /* ino */
	346	mode, /* mode */
	347	(long) uid, /* uid */
	348	(long) gid, /* gid */
	349	nlinks, /* nlink */
	350	(long) buf.st_mtime, /* mtime */
	351	size, /* filesize */
	352	3, /* major */
	353	1, /* minor */
	354	0, /* rmajor */
	355	0, /* rminor */
	356	namesize, /* namesize */
	357	0); /* chksum */
	358	push_hdr(s);
	359	push_string(name);
	360	push_pad();
	361
	362	if (size) {
6d87fea4 MF	363	if (fwrite(filebuf, size, 1, stdout) != 1) {
	364	fprintf(stderr, "writing filebuf failed\n");
	365	goto error;
	366	}
24fa5096 LR	367	offset += size;
	368	push_pad();
	369	}
	370
	371	name += namesize;
	372	}
	373	ino++;
1da177e4 LT	374	rc = 0;
	375
	376	error:
	377	if (filebuf) free(filebuf);
	378	if (file >= 0) close(file);
	379	return rc;
	380	}
	381
3b1ec9fb SG	382	static char cpio_replace_env(char new_location)
3b1ec9fb SG	383	{
20f1de65 KC	384	char expanded[PATH_MAX + 1];
	385	char env_var[PATH_MAX + 1];
	386	char *start;
	387	char *end;
	388
	389	for (start = NULL; (start = strstr(new_location, "${")); ) {
	390	end = strchr(start, '}');
	391	if (start < end) {
	392	env_var = expanded = '\0';
	393	strncat(env_var, start + 2, end - start - 2);
	394	strncat(expanded, new_location, start - new_location);
	395	strncat(expanded, getenv(env_var),
	396	PATH_MAX - strlen(expanded));
	397	strncat(expanded, end + 1,
	398	PATH_MAX - strlen(expanded));
	399	strncpy(new_location, expanded, PATH_MAX);
	400	new_location[PATH_MAX] = 0;
	401	} else
	402	break;
	403	}
	404
	405	return new_location;
3b1ec9fb SG	406	}
3b1ec9fb SG	407
1da177e4 LT	408	static int cpio_mkfile_line(const char *line)
	409	{
	410	char name[PATH_MAX + 1];
24fa5096	411	char dname = NULL; / malloc'ed buffer for hard links */
1da177e4 LT	412	char location[PATH_MAX + 1];
	413	unsigned int mode;
	414	int uid;
	415	int gid;
24fa5096 LR	416	int nlinks = 1;
24fa5096 LR	417	int end = 0, dname_len = 0;
1da177e4 LT	418	int rc = -1;
1da177e4 LT	419
24fa5096 LR	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)) {
1da177e4 LT	423	fprintf(stderr, "Unrecognized file format '%s'", line);
	424	goto fail;
	425	}
24fa5096 LR	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	}
3b1ec9fb SG	453	rc = cpio_mkfile(dname, cpio_replace_env(location),
3b1ec9fb SG	454	mode, uid, gid, nlinks);
1da177e4	455	fail:
24fa5096	456	if (dname_len) free(dname);
1da177e4 LT	457	return rc;
	458	}
	459
5c725138	460	static void usage(const char *prog)
1da177e4 LT	461	{
1da177e4 LT	462	fprintf(stderr, "Usage:\n"
a8b8017c	463	"\t%s [-t <timestamp>] <cpio_list>\n"
1da177e4 LT	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"
24fa5096	469	"file <name> <location> <mode> <uid> <gid> [<hard links>]\n"
1da177e4 LT	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"
24fa5096 LR	476	"<name> name of the file/dir/nod/etc in the archive\n"
24fa5096 LR	477	"<location> location of the file in the current filesystem\n"
3b1ec9fb	478	" expands shell variables quoted with ${}\n"
24fa5096 LR	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"
1da177e4 LT	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"
a8b8017c MM	494	"file /sbin/kinit /usr/src/klibc/kinit/kinit 0755 0 0\n"
	495	"\n"
	496	"<timestamp> is time in seconds since Epoch that will be used\n"
	497	"as mtime for symlinks, special files and directories. The default\n"
	498	"is to use the current time for these entries.\n",
1da177e4 LT	499	prog);
	500	}
	501
	502	struct file_handler file_handler_table[] = {
	503	{
	504	.type = "file",
	505	.handler = cpio_mkfile_line,
	506	}, {
	507	.type = "nod",
	508	.handler = cpio_mknod_line,
	509	}, {
	510	.type = "dir",
	511	.handler = cpio_mkdir_line,
	512	}, {
	513	.type = "slink",
	514	.handler = cpio_mkslink_line,
	515	}, {
	516	.type = "pipe",
	517	.handler = cpio_mkpipe_line,
	518	}, {
	519	.type = "sock",
	520	.handler = cpio_mksock_line,
	521	}, {
	522	.type = NULL,
	523	.handler = NULL,
	524	}
	525	};
	526
	527	#define LINE_SIZE (2 * PATH_MAX + 50)
	528
	529	int main (int argc, char *argv[])
	530	{
	531	FILE *cpio_list;
	532	char line[LINE_SIZE];
	533	char args, type;
	534	int ec = 0;
	535	int line_nr = 0;
a8b8017c MM	536	const char *filename;
	537
	538	default_mtime = time(NULL);
	539	while (1) {
	540	int opt = getopt(argc, argv, "t:h");
	541	char *invalid;
	542
	543	if (opt == -1)
	544	break;
	545	switch (opt) {
	546	case 't':
	547	default_mtime = strtol(optarg, &invalid, 10);
	548	if (!optarg \|\| invalid) {
	549	fprintf(stderr, "Invalid timestamp: %s\n",
	550	optarg);
	551	usage(argv[0]);
	552	exit(1);
	553	}
	554	break;
	555	case 'h':
	556	case '?':
	557	usage(argv[0]);
	558	exit(opt == 'h' ? 0 : 1);
	559	}
	560	}
1da177e4	561
a8b8017c	562	if (argc - optind != 1) {
1da177e4 LT	563	usage(argv[0]);
	564	exit(1);
	565	}
a8b8017c MM	566	filename = argv[optind];
a8b8017c MM	567	if (!strcmp(filename, "-"))
f2434ec1	568	cpio_list = stdin;
a8b8017c	569	else if (!(cpio_list = fopen(filename, "r"))) {
1da177e4	570	fprintf(stderr, "ERROR: unable to open '%s': %s\n\n",
a8b8017c	571	filename, strerror(errno));
1da177e4 LT	572	usage(argv[0]);
	573	exit(1);
	574	}
	575
	576	while (fgets(line, LINE_SIZE, cpio_list)) {
	577	int type_idx;
	578	size_t slen = strlen(line);
	579
	580	line_nr++;
	581
	582	if ('#' == *line) {
	583	/* comment - skip to next line */
	584	continue;
	585	}
	586
	587	if (! (type = strtok(line, " \t"))) {
	588	fprintf(stderr,
	589	"ERROR: incorrect format, could not locate file type line %d: '%s'\n",
	590	line_nr, line);
	591	ec = -1;
aa1e816f	592	break;
1da177e4 LT	593	}
	594
	595	if ('\n' == *type) {
	596	/* a blank line */
	597	continue;
	598	}
	599
	600	if (slen == strlen(type)) {
	601	/* must be an empty line */
	602	continue;
	603	}
	604
	605	if (! (args = strtok(NULL, "\n"))) {
	606	fprintf(stderr,
	607	"ERROR: incorrect format, newline required line %d: '%s'\n",
	608	line_nr, line);
	609	ec = -1;
	610	}
	611
	612	for (type_idx = 0; file_handler_table[type_idx].type; type_idx++) {
	613	int rc;
	614	if (! strcmp(line, file_handler_table[type_idx].type)) {
	615	if ((rc = file_handler_table[type_idx].handler(args))) {
	616	ec = rc;
	617	fprintf(stderr, " line %d\n", line_nr);
	618	}
	619	break;
	620	}
	621	}
	622
	623	if (NULL == file_handler_table[type_idx].type) {
	624	fprintf(stderr, "unknown file type line %d: '%s'\n",
	625	line_nr, line);
	626	}
	627	}
aa1e816f JJ	628	if (ec == 0)
aa1e816f JJ	629	cpio_trailer();
1da177e4 LT	630
	631	exit(ec);
	632	}