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 * Hard link support by Luciano Rocha
18 */
19
20#define xstr(s) #s
21#define str(s) xstr(s)
22
23static unsigned int offset;
24static unsigned int ino = 721;
25
26struct file_handler {
27	const char *type;
28	int (*handler)(const char *line);
29};
30
31static 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
40static void push_pad (void)
41{
42	while (offset & 3) {
43		putchar(0);
44		offset++;
45	}
46}
47
48static 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
65static void push_hdr(const char *s)
66{
67	fputs(s, stdout);
68	offset += 110;
69}
70
71static 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
101static 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
131static 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
149static 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
176enum generic_types {
177	GT_DIR,
178	GT_PIPE,
179	GT_SOCK
180};
181
182struct generic_type {
183	const char *type;
184	mode_t mode;
185};
186
187static 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
202static 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
221static int cpio_mkdir_line(const char *line)
222{
223	return cpio_mkgeneric_line(line, GT_DIR);
224}
225
226static int cpio_mkpipe_line(const char *line)
227{
228	return cpio_mkgeneric_line(line, GT_PIPE);
229}
230
231static int cpio_mksock_line(const char *line)
232{
233	return cpio_mkgeneric_line(line, GT_SOCK);
234}
235
236static 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
269static 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
290static int cpio_mkfile(const char *name, const char *location,
291			unsigned int mode, uid_t uid, gid_t gid,
292			unsigned int nlinks)
293{
294	char s[256];
295	char *filebuf = NULL;
296	struct stat buf;
297	long size;
298	int file = -1;
299	int retval;
300	int rc = -1;
301	int namesize;
302	int i;
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
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			if (fwrite(filebuf, size, 1, stdout) != 1) {
358				fprintf(stderr, "writing filebuf failed\n");
359				goto error;
360			}
361			offset += size;
362			push_pad();
363		}
364
365		name += namesize;
366	}
367	ino++;
368	rc = 0;
369
370error:
371	if (filebuf) free(filebuf);
372	if (file >= 0) close(file);
373	return rc;
374}
375
376static char *cpio_replace_env(char *new_location)
377{
378       char expanded[PATH_MAX + 1];
379       char env_var[PATH_MAX + 1];
380       char *start;
381       char *end;
382
383       for (start = NULL; (start = strstr(new_location, "${")); ) {
384               end = strchr(start, '}');
385               if (start < end) {
386                       *env_var = *expanded = '\0';
387                       strncat(env_var, start + 2, end - start - 2);
388                       strncat(expanded, new_location, start - new_location);
389                       strncat(expanded, getenv(env_var), PATH_MAX);
390                       strncat(expanded, end + 1, PATH_MAX);
391                       strncpy(new_location, expanded, PATH_MAX);
392               } else
393                       break;
394       }
395
396       return new_location;
397}
398
399
400static int cpio_mkfile_line(const char *line)
401{
402	char name[PATH_MAX + 1];
403	char *dname = NULL; /* malloc'ed buffer for hard links */
404	char location[PATH_MAX + 1];
405	unsigned int mode;
406	int uid;
407	int gid;
408	int nlinks = 1;
409	int end = 0, dname_len = 0;
410	int rc = -1;
411
412	if (5 > sscanf(line, "%" str(PATH_MAX) "s %" str(PATH_MAX)
413				"s %o %d %d %n",
414				name, location, &mode, &uid, &gid, &end)) {
415		fprintf(stderr, "Unrecognized file format '%s'", line);
416		goto fail;
417	}
418	if (end && isgraph(line[end])) {
419		int len;
420		int nend;
421
422		dname = malloc(strlen(line));
423		if (!dname) {
424			fprintf (stderr, "out of memory (%d)\n", dname_len);
425			goto fail;
426		}
427
428		dname_len = strlen(name) + 1;
429		memcpy(dname, name, dname_len);
430
431		do {
432			nend = 0;
433			if (sscanf(line + end, "%" str(PATH_MAX) "s %n",
434					name, &nend) < 1)
435				break;
436			len = strlen(name) + 1;
437			memcpy(dname + dname_len, name, len);
438			dname_len += len;
439			nlinks++;
440			end += nend;
441		} while (isgraph(line[end]));
442	} else {
443		dname = name;
444	}
445	rc = cpio_mkfile(dname, cpio_replace_env(location),
446	                 mode, uid, gid, nlinks);
447 fail:
448	if (dname_len) free(dname);
449	return rc;
450}
451
452static void usage(const char *prog)
453{
454	fprintf(stderr, "Usage:\n"
455		"\t%s <cpio_list>\n"
456		"\n"
457		"<cpio_list> is a file containing newline separated entries that\n"
458		"describe the files to be included in the initramfs archive:\n"
459		"\n"
460		"# a comment\n"
461		"file <name> <location> <mode> <uid> <gid> [<hard links>]\n"
462		"dir <name> <mode> <uid> <gid>\n"
463		"nod <name> <mode> <uid> <gid> <dev_type> <maj> <min>\n"
464		"slink <name> <target> <mode> <uid> <gid>\n"
465		"pipe <name> <mode> <uid> <gid>\n"
466		"sock <name> <mode> <uid> <gid>\n"
467		"\n"
468		"<name>       name of the file/dir/nod/etc in the archive\n"
469		"<location>   location of the file in the current filesystem\n"
470		"             expands shell variables quoted with ${}\n"
471		"<target>     link target\n"
472		"<mode>       mode/permissions of the file\n"
473		"<uid>        user id (0=root)\n"
474		"<gid>        group id (0=root)\n"
475		"<dev_type>   device type (b=block, c=character)\n"
476		"<maj>        major number of nod\n"
477		"<min>        minor number of nod\n"
478		"<hard links> space separated list of other links to file\n"
479		"\n"
480		"example:\n"
481		"# A simple initramfs\n"
482		"dir /dev 0755 0 0\n"
483		"nod /dev/console 0600 0 0 c 5 1\n"
484		"dir /root 0700 0 0\n"
485		"dir /sbin 0755 0 0\n"
486		"file /sbin/kinit /usr/src/klibc/kinit/kinit 0755 0 0\n",
487		prog);
488}
489
490struct file_handler file_handler_table[] = {
491	{
492		.type    = "file",
493		.handler = cpio_mkfile_line,
494	}, {
495		.type    = "nod",
496		.handler = cpio_mknod_line,
497	}, {
498		.type    = "dir",
499		.handler = cpio_mkdir_line,
500	}, {
501		.type    = "slink",
502		.handler = cpio_mkslink_line,
503	}, {
504		.type    = "pipe",
505		.handler = cpio_mkpipe_line,
506	}, {
507		.type    = "sock",
508		.handler = cpio_mksock_line,
509	}, {
510		.type    = NULL,
511		.handler = NULL,
512	}
513};
514
515#define LINE_SIZE (2 * PATH_MAX + 50)
516
517int main (int argc, char *argv[])
518{
519	FILE *cpio_list;
520	char line[LINE_SIZE];
521	char *args, *type;
522	int ec = 0;
523	int line_nr = 0;
524
525	if (2 != argc) {
526		usage(argv[0]);
527		exit(1);
528	}
529
530	if (!strcmp(argv[1], "-"))
531		cpio_list = stdin;
532	else if (! (cpio_list = fopen(argv[1], "r"))) {
533		fprintf(stderr, "ERROR: unable to open '%s': %s\n\n",
534			argv[1], strerror(errno));
535		usage(argv[0]);
536		exit(1);
537	}
538
539	while (fgets(line, LINE_SIZE, cpio_list)) {
540		int type_idx;
541		size_t slen = strlen(line);
542
543		line_nr++;
544
545		if ('#' == *line) {
546			/* comment - skip to next line */
547			continue;
548		}
549
550		if (! (type = strtok(line, " \t"))) {
551			fprintf(stderr,
552				"ERROR: incorrect format, could not locate file type line %d: '%s'\n",
553				line_nr, line);
554			ec = -1;
555			break;
556		}
557
558		if ('\n' == *type) {
559			/* a blank line */
560			continue;
561		}
562
563		if (slen == strlen(type)) {
564			/* must be an empty line */
565			continue;
566		}
567
568		if (! (args = strtok(NULL, "\n"))) {
569			fprintf(stderr,
570				"ERROR: incorrect format, newline required line %d: '%s'\n",
571				line_nr, line);
572			ec = -1;
573		}
574
575		for (type_idx = 0; file_handler_table[type_idx].type; type_idx++) {
576			int rc;
577			if (! strcmp(line, file_handler_table[type_idx].type)) {
578				if ((rc = file_handler_table[type_idx].handler(args))) {
579					ec = rc;
580					fprintf(stderr, " line %d\n", line_nr);
581				}
582				break;
583			}
584		}
585
586		if (NULL == file_handler_table[type_idx].type) {
587			fprintf(stderr, "unknown file type line %d: '%s'\n",
588				line_nr, line);
589		}
590	}
591	if (ec == 0)
592		cpio_trailer();
593
594	exit(ec);
595}
596