[net-next-2.6.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;

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];
	time_t mtime = time(NULL);

	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) 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];
	time_t mtime = time(NULL);

	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) 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];
	time_t mtime = time(NULL);

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

	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) 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;
	int i;

	mode |= S_IFREG;

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

	file = open (location, O_RDONLY);
	if (file < 0) {
		fprintf (stderr, "File %s could not be opened for reading\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;

		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) {
			fwrite(filebuf, size, 1, stdout);
			offset += size;
			push_pad();
		}

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

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, location, mode, uid, gid, nlinks);
 fail:
	if (dname_len) free(dname);
	return rc;
}

void usage(const char *prog)
{
	fprintf(stderr, "Usage:\n"
		"\t%s <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"
		"<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",
		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;

	if (2 != argc) {
		usage(argv[0]);
		exit(1);
	}

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