[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
 */

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

/* Not marked static to keep the compiler quiet, as no one uses this yet... */
static int cpio_mkfile(const char *name, const char *location,
			unsigned int mode, uid_t uid, gid_t gid)
{
	char s[256];
	char *filebuf = NULL;
	struct stat buf;
	int file = -1;
	int retval;
	int rc = -1;

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

	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) buf.st_mtime,	/* mtime */
		(int) buf.st_size,	/* filesize */
		3,			/* major */
		1,			/* minor */
		0,			/* rmajor */
		0,			/* rminor */
		(unsigned)strlen(name) + 1,/* namesize */
		0);			/* chksum */
	push_hdr(s);
	push_string(name);
	push_pad();

	fwrite(filebuf, buf.st_size, 1, stdout);
	offset += buf.st_size;
	push_pad();
	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 location[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, location, &mode, &uid, &gid)) {
		fprintf(stderr, "Unrecognized file format '%s'", line);
		goto fail;
	}
	rc = cpio_mkfile(name, location, mode, uid, gid);
 fail:
	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>\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"
		"\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 (! (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;
		}

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