1 #include <u.h>
2 #include <libc.h>
3 #include <auth.h>
4 #include <bio.h>
5 
6 #define mkdir plan9mkdir
7 #define getmode plan9_getmode
8 #define setuid plan9_setuid
9 
10 enum{
11 	LEN	= 8*1024,
12 	HUNKS	= 128,
13 
14 	/*
15 	 * types of destination file sytems
16 	 */
17 	Kfs = 0,
18 	Fs,
19 	Archive,
20 };
21 
22 typedef struct File	File;
23 
24 struct File{
25 	char	*new;
26 	char	*elem;
27 	char	*old;
28 	char	*uid;
29 	char	*gid;
30 	ulong	mode;
31 };
32 
33 void	arch(Dir*);
34 void	copy(Dir*);
35 int	copyfile(File*, Dir*, int);
36 void*	emalloc(ulong);
37 void	error(char *, ...);
38 void	freefile(File*);
39 File*	getfile(File*);
40 char*	getmode(char*, ulong*);
41 char*	getname(char*, char**);
42 char*	getpath(char*);
43 void	kfscmd(char *);
44 void	mkdir(Dir*);
45 int	mkfile(File*);
46 void	mkfs(File*, int);
47 char*	mkpath(char*, char*);
48 void	mktree(File*, int);
49 void	mountkfs(char*);
50 void	printfile(File*);
51 void	setnames(File*);
52 void	setusers(void);
53 void	skipdir(void);
54 char*	strdup(char*);
55 int	uptodate(Dir*, char*);
56 void	usage(void);
57 void	warn(char *, ...);
58 
59 Biobuf	*b;
60 Biobuf	bout;			/* stdout when writing archive */
61 uchar	boutbuf[2*LEN];
62 char	newfile[LEN];
63 char	oldfile[LEN];
64 char	*proto;
65 char	*cputype;
66 char	*users;
67 char	*oldroot;
68 char	*newroot;
69 char	*prog = "mkfs";
70 int	lineno;
71 char	*buf;
72 char	*zbuf;
73 int	buflen = 1024-8;
74 int	indent;
75 int	verb;
76 int	modes;
77 int	ream;
78 int	debug;
79 int	xflag;
80 int	sfd;
81 int	fskind;			/* Kfs, Fs, Archive */
82 int	setuid;			/* on Fs: set uid and gid? */
83 char	*user;
84 
85 void
86 main(int argc, char **argv)
87 {
88 	File file;
89 	char *name;
90 	int i, errs;
91 
92 	quotefmtinstall();
93 	user = getuser();
94 	name = "";
95 	memset(&file, 0, sizeof file);
96 	file.new = "";
97 	file.old = 0;
98 	oldroot = "";
99 	newroot = "/n/kfs";
100 	users = 0;
101 	fskind = Kfs;
102 	ARGBEGIN{
103 	case 'a':
104 		if(fskind != Kfs) {
105 			fprint(2, "cannot use -a with -d\n");
106 			usage();
107 		}
108 		fskind = Archive;
109 		newroot = "";
110 		Binits(&bout, 1, OWRITE, boutbuf, sizeof boutbuf);
111 		break;
112 	case 'd':
113 		if(fskind != Kfs) {
114 			fprint(2, "cannot use -d with -a\n");
115 			usage();
116 		}
117 		fskind = Fs;
118 		newroot = ARGF();
119 		break;
120 	case 'D':
121 		debug = 1;
122 		break;
123 	case 'n':
124 		name = EARGF(usage());
125 		break;
126 	case 'p':
127 		modes = 1;
128 		break;
129 	case 'r':
130 		ream = 1;
131 		break;
132 	case 's':
133 		oldroot = ARGF();
134 		break;
135 	case 'u':
136 		users = ARGF();
137 		break;
138 	case 'U':
139 		setuid = 1;
140 		break;
141 	case 'v':
142 		verb = 1;
143 		break;
144 	case 'x':
145 		xflag = 1;
146 		break;
147 	case 'z':
148 		buflen = atoi(ARGF())-8;
149 		break;
150 	default:
151 		usage();
152 	}ARGEND
153 
154 	if(!argc)
155 		usage();
156 
157 	buf = emalloc(buflen);
158 	zbuf = emalloc(buflen);
159 	memset(zbuf, 0, buflen);
160 
161 	mountkfs(name);
162 	kfscmd("allow");
163 	proto = "users";
164 	setusers();
165 	cputype = getenv("cputype");
166 	if(cputype == 0)
167 		cputype = "68020";
168 
169 	errs = 0;
170 	for(i = 0; i < argc; i++){
171 		proto = argv[i];
172 		fprint(2, "processing %q\n", proto);
173 
174 		b = Bopen(proto, OREAD);
175 		if(!b){
176 			fprint(2, "%q: can't open %q: skipping\n", prog, proto);
177 			errs++;
178 			continue;
179 		}
180 
181 		lineno = 0;
182 		indent = 0;
183 		mkfs(&file, -1);
184 		Bterm(b);
185 	}
186 	fprint(2, "file system made\n");
187 	kfscmd("disallow");
188 	kfscmd("sync");
189 	if(errs)
190 		exits("skipped protos");
191 	if(fskind == Archive){
192 		Bprint(&bout, "end of archive\n");
193 		Bterm(&bout);
194 	}
195 	exits(0);
196 }
197 
198 void
199 mkfs(File *me, int level)
200 {
201 	File *child;
202 	int rec;
203 
204 	child = getfile(me);
205 	if(!child)
206 		return;
207 	if((child->elem[0] == '+' || child->elem[0] == '*') && child->elem[1] == '\0'){
208 		rec = child->elem[0] == '+';
209 		free(child->new);
210 		child->new = strdup(me->new);
211 		setnames(child);
212 		mktree(child, rec);
213 		freefile(child);
214 		child = getfile(me);
215 	}
216 	while(child && indent > level){
217 		if(mkfile(child))
218 			mkfs(child, indent);
219 		freefile(child);
220 		child = getfile(me);
221 	}
222 	if(child){
223 		freefile(child);
224 		Bseek(b, -Blinelen(b), 1);
225 		lineno--;
226 	}
227 }
228 
229 void
230 mktree(File *me, int rec)
231 {
232 	File child;
233 	Dir *d;
234 	int i, n, fd;
235 
236 	fd = open(oldfile, OREAD);
237 	if(fd < 0){
238 		warn("can't open %q: %r", oldfile);
239 		return;
240 	}
241 
242 	child = *me;
243 	while((n = dirread(fd, &d)) > 0){
244 		for(i = 0; i < n; i++){
245 			child.new = mkpath(me->new, d[i].name);
246 			if(me->old)
247 				child.old = mkpath(me->old, d[i].name);
248 			child.elem = d[i].name;
249 			setnames(&child);
250 			if(copyfile(&child, &d[i], 1) && rec)
251 				mktree(&child, rec);
252 			free(child.new);
253 			if(child.old)
254 				free(child.old);
255 		}
256 	}
257 	close(fd);
258 }
259 
260 int
261 mkfile(File *f)
262 {
263 	Dir *dir;
264 
265 	if((dir = dirstat(oldfile)) == nil){
266 		warn("can't stat file %q: %r", oldfile);
267 		skipdir();
268 		return 0;
269 	}
270 	return copyfile(f, dir, 0);
271 }
272 
273 int
274 copyfile(File *f, Dir *d, int permonly)
275 {
276 	ulong mode;
277 	Dir nd;
278 
279 	if(xflag){
280 		Bprint(&bout, "%q\t%ld\t%lld\n", f->new, d->mtime, d->length);
281 		return (d->mode & DMDIR) != 0;
282 	}
283 	if(verb && (fskind == Archive || ream))
284 		fprint(2, "%q\n", f->new);
285 	d->name = f->elem;
286 	if(d->type != 'M' && d->type != 'Z'){
287 		d->uid = "sys";
288 		d->gid = "sys";
289 		mode = (d->mode >> 6) & 7;
290 		d->mode |= mode | (mode << 3);
291 	}
292 	if(strcmp(f->uid, "-") != 0)
293 		d->uid = f->uid;
294 	if(strcmp(f->gid, "-") != 0)
295 		d->gid = f->gid;
296 	if(fskind == Fs && !setuid){
297 		d->uid = "";
298 		d->gid = "";
299 	}
300 	if(f->mode != ~0){
301 		if(permonly)
302 			d->mode = (d->mode & ~0666) | (f->mode & 0666);
303 		else if((d->mode&DMDIR) != (f->mode&DMDIR))
304 			warn("inconsistent mode for %q", f->new);
305 		else
306 			d->mode = f->mode;
307 	}
308 	if(!uptodate(d, newfile)){
309 		if(verb && (fskind != Archive && ream == 0))
310 			fprint(2, "%q\n", f->new);
311 		if(d->mode & DMDIR)
312 			mkdir(d);
313 		else
314 			copy(d);
315 	}else if(modes){
316 		nulldir(&nd);
317 		nd.mode = d->mode;
318 		nd.gid = d->gid;
319 		nd.mtime = d->mtime;
320 		if(verb && (fskind != Archive && ream == 0))
321 			fprint(2, "%q\n", f->new);
322 		if(dirwstat(newfile, &nd) < 0)
323 			warn("can't set modes for %q: %r", f->new);
324 		nulldir(&nd);
325 		nd.uid = d->uid;
326 		dirwstat(newfile, &nd);
327 	}
328 	return (d->mode & DMDIR) != 0;
329 }
330 
331 /*
332  * check if file to is up to date with
333  * respect to the file represented by df
334  */
335 int
336 uptodate(Dir *df, char *to)
337 {
338 	int ret;
339 	Dir *dt;
340 
341 	if(fskind == Archive || ream || (dt = dirstat(to)) == nil)
342 		return 0;
343 	ret = dt->mtime >= df->mtime;
344 	free(dt);
345 	return ret;
346 }
347 
348 void
349 copy(Dir *d)
350 {
351 	char cptmp[LEN], *p;
352 	int f, t, n, needwrite, nowarnyet = 1;
353 	vlong tot, len;
354 	Dir nd;
355 
356 	f = open(oldfile, OREAD);
357 	if(f < 0){
358 		warn("can't open %q: %r", oldfile);
359 		return;
360 	}
361 	t = -1;
362 	if(fskind == Archive)
363 		arch(d);
364 	else{
365 		strcpy(cptmp, newfile);
366 		p = utfrrune(cptmp, L'/');
367 		if(!p)
368 			error("internal temporary file error");
369 		strcpy(p+1, "__mkfstmp");
370 		t = create(cptmp, OWRITE, 0666);
371 		if(t < 0){
372 			warn("can't create %q: %r", newfile);
373 			close(f);
374 			return;
375 		}
376 	}
377 
378 	needwrite = 0;
379 	for(tot = 0; tot < d->length; tot += n){
380 		len = d->length - tot;
381 		/* don't read beyond d->length */
382 		if (len > buflen)
383 			len = buflen;
384 		n = read(f, buf, len);
385 		if(n <= 0) {
386 			if(n < 0 && nowarnyet) {
387 				warn("can't read %q: %r", oldfile);
388 				nowarnyet = 0;
389 			}
390 			/*
391 			 * don't quit: pad to d->length (in pieces) to agree
392 			 * with the length in the header, already emitted.
393 			 */
394 			memset(buf, 0, len);
395 			n = len;
396 		}
397 		if(fskind == Archive){
398 			if(Bwrite(&bout, buf, n) != n)
399 				error("write error: %r");
400 		}else if(memcmp(buf, zbuf, n) == 0){
401 			if(seek(t, n, 1) < 0)
402 				error("can't write zeros to %q: %r", newfile);
403 			needwrite = 1;
404 		}else{
405 			if(write(t, buf, n) < n)
406 				error("can't write %q: %r", newfile);
407 			needwrite = 0;
408 		}
409 	}
410 	close(f);
411 	if(needwrite){
412 		if(seek(t, -1, 1) < 0 || write(t, zbuf, 1) != 1)
413 			error("can't write zero at end of %q: %r", newfile);
414 	}
415 	if(tot != d->length){
416 		/* this should no longer happen */
417 		warn("wrong number of bytes written to %q (was %lld should be %lld)\n",
418 			newfile, tot, d->length);
419 		if(fskind == Archive){
420 			warn("seeking to proper position\n");
421 			/* does no good if stdout is a pipe */
422 			Bseek(&bout, d->length - tot, 1);
423 		}
424 	}
425 	if(fskind == Archive)
426 		return;
427 	remove(newfile);
428 	nulldir(&nd);
429 	nd.mode = d->mode;
430 	nd.gid = d->gid;
431 	nd.mtime = d->mtime;
432 	nd.name = d->name;
433 	if(dirfwstat(t, &nd) < 0)
434 		error("can't move tmp file to %q: %r", newfile);
435 	nulldir(&nd);
436 	nd.uid = d->uid;
437 	dirfwstat(t, &nd);
438 	close(t);
439 }
440 
441 void
442 mkdir(Dir *d)
443 {
444 	Dir *d1;
445 	Dir nd;
446 	int fd;
447 
448 	if(fskind == Archive){
449 		arch(d);
450 		return;
451 	}
452 	fd = create(newfile, OREAD, d->mode);
453 	nulldir(&nd);
454 	nd.mode = d->mode;
455 	nd.gid = d->gid;
456 	nd.mtime = d->mtime;
457 	if(fd < 0){
458 		if((d1 = dirstat(newfile)) == nil || !(d1->mode & DMDIR)){
459 			free(d1);
460 			error("can't create %q", newfile);
461 		}
462 		free(d1);
463 		if(dirwstat(newfile, &nd) < 0)
464 			warn("can't set modes for %q: %r", newfile);
465 		nulldir(&nd);
466 		nd.uid = d->uid;
467 		dirwstat(newfile, &nd);
468 		return;
469 	}
470 	if(dirfwstat(fd, &nd) < 0)
471 		warn("can't set modes for %q: %r", newfile);
472 	nulldir(&nd);
473 	nd.uid = d->uid;
474 	dirfwstat(fd, &nd);
475 	close(fd);
476 }
477 
478 void
479 arch(Dir *d)
480 {
481 	Bprint(&bout, "%q %luo %q %q %lud %lld\n",
482 		newfile, d->mode, d->uid, d->gid, d->mtime, d->length);
483 }
484 
485 char *
486 mkpath(char *prefix, char *elem)
487 {
488 	char *p;
489 	int n;
490 
491 	n = strlen(prefix) + strlen(elem) + 2;
492 	p = emalloc(n);
493 	sprint(p, "%s/%s", prefix, elem);
494 	return p;
495 }
496 
497 char *
498 strdup(char *s)
499 {
500 	char *t;
501 
502 	t = emalloc(strlen(s) + 1);
503 	return strcpy(t, s);
504 }
505 
506 void
507 setnames(File *f)
508 {
509 	sprint(newfile, "%s%s", newroot, f->new);
510 	if(f->old){
511 		if(f->old[0] == '/')
512 			sprint(oldfile, "%s%s", oldroot, f->old);
513 		else
514 			strcpy(oldfile, f->old);
515 	}else
516 		sprint(oldfile, "%s%s", oldroot, f->new);
517 	if(strlen(newfile) >= sizeof newfile
518 	|| strlen(oldfile) >= sizeof oldfile)
519 		error("name overfile");
520 }
521 
522 void
523 freefile(File *f)
524 {
525 	if(f->old)
526 		free(f->old);
527 	if(f->new)
528 		free(f->new);
529 	free(f);
530 }
531 
532 /*
533  * skip all files in the proto that
534  * could be in the current dir
535  */
536 void
537 skipdir(void)
538 {
539 	char *p, c;
540 	int level;
541 
542 	if(indent < 0 || b == nil)	/* b is nil when copying adm/users */
543 		return;
544 	level = indent;
545 	for(;;){
546 		indent = 0;
547 		p = Brdline(b, '\n');
548 		lineno++;
549 		if(!p){
550 			indent = -1;
551 			return;
552 		}
553 		while((c = *p++) != '\n')
554 			if(c == ' ')
555 				indent++;
556 			else if(c == '\t')
557 				indent += 8;
558 			else
559 				break;
560 		if(indent <= level){
561 			Bseek(b, -Blinelen(b), 1);
562 			lineno--;
563 			return;
564 		}
565 	}
566 }
567 
568 File*
569 getfile(File *old)
570 {
571 	File *f;
572 	char *elem;
573 	char *p;
574 	int c;
575 
576 	if(indent < 0)
577 		return 0;
578 loop:
579 	indent = 0;
580 	p = Brdline(b, '\n');
581 	lineno++;
582 	if(!p){
583 		indent = -1;
584 		return 0;
585 	}
586 	while((c = *p++) != '\n')
587 		if(c == ' ')
588 			indent++;
589 		else if(c == '\t')
590 			indent += 8;
591 		else
592 			break;
593 	if(c == '\n' || c == '#')
594 		goto loop;
595 	p--;
596 	f = emalloc(sizeof *f);
597 	p = getname(p, &elem);
598 	if(debug)
599 		fprint(2, "getfile: %q root %q\n", elem, old->new);
600 	f->new = mkpath(old->new, elem);
601 	f->elem = utfrrune(f->new, L'/') + 1;
602 	p = getmode(p, &f->mode);
603 	p = getname(p, &f->uid);
604 	if(!*f->uid)
605 		f->uid = "-";
606 	p = getname(p, &f->gid);
607 	if(!*f->gid)
608 		f->gid = "-";
609 	f->old = getpath(p);
610 	if(f->old && strcmp(f->old, "-") == 0){
611 		free(f->old);
612 		f->old = 0;
613 	}
614 	setnames(f);
615 
616 	if(debug)
617 		printfile(f);
618 
619 	return f;
620 }
621 
622 char*
623 getpath(char *p)
624 {
625 	char *q, *new;
626 	int c, n;
627 
628 	while((c = *p) == ' ' || c == '\t')
629 		p++;
630 	q = p;
631 	while((c = *q) != '\n' && c != ' ' && c != '\t')
632 		q++;
633 	if(q == p)
634 		return 0;
635 	n = q - p;
636 	new = emalloc(n + 1);
637 	memcpy(new, p, n);
638 	new[n] = 0;
639 	return new;
640 }
641 
642 char*
643 getname(char *p, char **buf)
644 {
645 	char *s, *start;
646 	int c;
647 
648 	while((c = *p) == ' ' || c == '\t')
649 		p++;
650 
651 	start = p;
652 	while((c = *p) != '\n' && c != ' ' && c != '\t' && c != '\0')
653 		p++;
654 
655 	*buf = malloc(p+1-start);
656 	if(*buf == nil)
657 		return nil;
658 	memmove(*buf, start, p-start);
659 	(*buf)[p-start] = '\0';
660 
661 	if(**buf == '$'){
662 		s = getenv(*buf+1);
663 		if(s == 0){
664 			warn("can't read environment variable %q", *buf+1);
665 			skipdir();
666 			free(*buf);
667 			return nil;
668 		}
669 		free(*buf);
670 		*buf = s;
671 	}
672 	return p;
673 }
674 
675 char*
676 getmode(char *p, ulong *xmode)
677 {
678 	char *buf, *s;
679 	ulong m;
680 
681 	*xmode = ~0;
682 	p = getname(p, &buf);
683 	if(p == nil)
684 		return nil;
685 
686 	s = buf;
687 	if(!*s || strcmp(s, "-") == 0)
688 		return p;
689 	m = 0;
690 	if(*s == 'd'){
691 		m |= DMDIR;
692 		s++;
693 	}
694 	if(*s == 'a'){
695 		m |= DMAPPEND;
696 		s++;
697 	}
698 	if(*s == 'l'){
699 		m |= DMEXCL;
700 		s++;
701 	}
702 	if(s[0] < '0' || s[0] > '7'
703 	|| s[1] < '0' || s[1] > '7'
704 	|| s[2] < '0' || s[2] > '7'
705 	|| s[3]){
706 		warn("bad mode specification %q", buf);
707 		free(buf);
708 		return p;
709 	}
710 	*xmode = m | strtoul(s, 0, 8);
711 	free(buf);
712 	return p;
713 }
714 
715 void
716 setusers(void)
717 {
718 	File file;
719 	int m;
720 
721 	if(fskind != Kfs)
722 		return;
723 	m = modes;
724 	modes = 1;
725 	file.uid = "adm";
726 	file.gid = "adm";
727 	file.mode = DMDIR|0775;
728 	file.new = "/adm";
729 	file.elem = "adm";
730 	file.old = 0;
731 	setnames(&file);
732 	strcpy(oldfile, file.new);	/* Don't use root for /adm */
733 	mkfile(&file);
734 	file.new = "/adm/users";
735 	file.old = users;
736 	file.elem = "users";
737 	file.mode = 0664;
738 	setnames(&file);
739 	if (file.old)
740 		strcpy(oldfile, file.old);	/* Don't use root for /adm/users */
741 	mkfile(&file);
742 	kfscmd("user");
743 	mkfile(&file);
744 	file.mode = DMDIR|0775;
745 	file.new = "/adm";
746 	file.old = "/adm";
747 	file.elem = "adm";
748 	setnames(&file);
749 	strcpy(oldfile, file.old);	/* Don't use root for /adm */
750 	mkfile(&file);
751 	modes = m;
752 }
753 
754 void
755 mountkfs(char *name)
756 {
757 	if(fskind != Kfs)
758 		return;
759 	sysfatal("no kfs: use -a or -d");
760 }
761 
762 void
763 kfscmd(char *cmd)
764 {
765 	char buf[4*1024];
766 	int n;
767 
768 	if(fskind != Kfs)
769 		return;
770 	if(write(sfd, cmd, strlen(cmd)) != strlen(cmd)){
771 		fprint(2, "%q: error writing %q: %r", prog, cmd);
772 		return;
773 	}
774 	for(;;){
775 		n = read(sfd, buf, sizeof buf - 1);
776 		if(n <= 0)
777 			return;
778 		buf[n] = '\0';
779 		if(strcmp(buf, "done") == 0 || strcmp(buf, "success") == 0)
780 			return;
781 		if(strcmp(buf, "unknown command") == 0){
782 			fprint(2, "%q: command %q not recognized\n", prog, cmd);
783 			return;
784 		}
785 	}
786 }
787 
788 void *
789 emalloc(ulong n)
790 {
791 	void *p;
792 
793 	if((p = malloc(n)) == 0)
794 		error("out of memory");
795 	return p;
796 }
797 
798 void
799 error(char *fmt, ...)
800 {
801 	char buf[1024];
802 	va_list arg;
803 
804 	sprint(buf, "%q: %q:%d: ", prog, proto, lineno);
805 	va_start(arg, fmt);
806 	vseprint(buf+strlen(buf), buf+sizeof(buf), fmt, arg);
807 	va_end(arg);
808 	fprint(2, "%s\n", buf);
809 	kfscmd("disallow");
810 	kfscmd("sync");
811 	exits(0);
812 }
813 
814 void
815 warn(char *fmt, ...)
816 {
817 	char buf[1024];
818 	va_list arg;
819 
820 	sprint(buf, "%q: %q:%d: ", prog, proto, lineno);
821 	va_start(arg, fmt);
822 	vseprint(buf+strlen(buf), buf+sizeof(buf), fmt, arg);
823 	va_end(arg);
824 	fprint(2, "%s\n", buf);
825 }
826 
827 void
828 printfile(File *f)
829 {
830 	if(f->old)
831 		fprint(2, "%q from %q %q %q %lo\n", f->new, f->old, f->uid, f->gid, f->mode);
832 	else
833 		fprint(2, "%q %q %q %lo\n", f->new, f->uid, f->gid, f->mode);
834 }
835 
836 void
837 usage(void)
838 {
839 	fprint(2, "usage: %q [-aprvx] [-d root] [-n name] [-s source] [-u users] [-z n] proto ...\n", prog);
840 	exits("usage");
841 }