find.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

register struct { 
	int f, t, s; 
} *p; 
{
	return(scomp((int)((Now - Statb.st_atime) / A_DAY), p->t, p->s));
}

/*
 * 003 GAG
 * ctime - status information change
 */
int
ctime(p)
register struct { 
	int f, t, s; 
} *p; 
{
	return(scomp((int)((Now - Statb.st_ctime) / A_DAY), p->t, p->s));
}

user(p)
register struct { 
	int f, u, s; 
} *p; 
{
	return(scomp(Statb.st_uid, p->u, p->s));
}

ino(p)
register struct { 
	int f, u, s; 
} *p;
{
	return(scomp((int)Statb.st_ino, p->u, p->s));
}

group(p)
register struct { 
	int f, u; 
} *p; 
{
	return(p->u == Statb.st_gid);
}

links(p)
register struct { 
	int f, link, s; 
} *p; 
{
	return(scomp(Statb.st_nlink, p->link, p->s));
}

size(p)
register struct { 
	int f, sz, s; 
} *p; 
{
	return(scomp((int)((Statb.st_size+511)>>9), p->sz, p->s));
}

perm(p)
register struct { 
	int f, per, s; 
} *p; 
{
	register int i;
	i = (p->s=='-') ? p->per : 07777; /* '-' means only arg bits */
	return((Statb.st_mode & i & 07777) == p->per);
}

type(p)
register struct { 
	int f, per, s; 
} *p;
{
	return((Statb.st_mode&S_IFMT)==p->per);
}

exeq(p)
register struct { 
	int f, com; 
} *p;
{
	(void) fflush(stdout); /* to flush possible `-print' */
	return(doex(p->com));
}

ok(p)
register struct { 
	int f, com; 
} *p;
{
	register int yes;
	register int c;  
	yes = 0;
	(void) fflush(stdout); /* to flush possible `-print' */
	(void) fprintf(stderr, "< %s ... %s > ?   ", Argv[p->com], Pathname);
	if((c=getchar())=='y') yes = 1;
	while(c!='\n') c = getchar();
	if(yes) return(doex(p->com));
	return(0);
}

#define MKSHORT(v, lv)	{						\
			U.l=1L;						\
			if(U.c[0]) U.l=lv, v[0]=U.s[1], v[1]=U.s[0]; 	\
			else U.l=lv, v[0]=U.s[0], v[1]=U.s[1];		\
			}

union {
	long l; 
	short s[2]; 
	char c[4]; 
} U;

long
mklong(v)
short v[];
{
	U.l = 1;
	if(U.c[0] /* VAX */)
		U.s[0] = v[1], U.s[1] = v[0];
	else
		U.s[0] = v[0], U.s[1] = v[1];
	return(U.l);
}

cpio()
{
#define MAGIC 070707
	struct header {
		short	h_magic,
			h_dev;
		ino_t	h_ino;			/* 004 */
		ushort	h_mode,			/* 004 */
			h_uid,
			h_gid;
		short	h_nlink,		/* 004 */
			h_rdev;
		short	h_mtime[2];
		short	h_namesize;
		short	h_filesize[2];
		char	h_name[256];
	} hdr;
	register int ifile, ct;
	register int i;
	static long fsz;

	hdr.h_magic = MAGIC;
	(void) strcpy(hdr.h_name,
		!strncmp(Pathname, "./", 2) ? Pathname+2 : Pathname);
	hdr.h_namesize = strlen(hdr.h_name) + 1;
	hdr.h_uid = Statb.st_uid;
	hdr.h_gid = Statb.st_gid;
	hdr.h_dev = Statb.st_dev;
	hdr.h_ino = Statb.st_ino;
	hdr.h_mode = Statb.st_mode;
	MKSHORT(hdr.h_mtime, Statb.st_mtime);
	hdr.h_nlink = Statb.st_nlink;
	fsz = hdr.h_mode & S_IFREG ? Statb.st_size : 0L;
	MKSHORT(hdr.h_filesize, fsz);
	hdr.h_rdev = Statb.st_rdev;
	if(EQ(hdr.h_name, "TRAILER!!!")) {
		bwrite((short *)&hdr, (sizeof hdr-256)+hdr.h_namesize);
		for(i = 0; i < 10; ++i)
			bwrite(Buf, 512);
		return;
	}
	if(!mklong(hdr.h_filesize))
		return;
	if((ifile = open(Fname, 0)) < 0) {
cerror:
		(void) fprintf(stderr,"find: cannot copy < %s >\n", hdr.h_name);
		return;
	}
	bwrite((short *)&hdr, (sizeof hdr-256)+hdr.h_namesize);
	for(fsz = mklong(hdr.h_filesize); fsz > 0; fsz -= 512) {
		ct = fsz>512 ? 512 : fsz;
		if(read(ifile, (char *)Buf, ct) < 0)
			goto cerror;
		bwrite(Buf, ct);
	}
	(void) close(ifile);
	return;
}

newer()
{
	return(Statb.st_mtime > Newer);
}

/* support functions */
scomp(a, b, s) /* funny signed compare */
register int a, b, s;
{
	if(s == '+')
		return(a > b);
	if(s == '-')
		return(a < (b * -1));
	return(a == b);
}

doex(com)
register int com;
{
	register int np;
	register char *na;
	register void (*oldi)(), (*oldq)();
	static char *nargv[50];
	int ccode;

	ccode = np = 0;
	while (na=Argv[com++]) {
		if(strcmp(na, ";")==0) break;
		if(strcmp(na, "{}")==0) nargv[np++] = Pathname;
		else nargv[np++] = na;
	}
	nargv[np] = 0;
	if (np==0) return(9);
	if(fork()) /*parent*/ {
		oldi = signal(SIGINT, SIG_IGN);
		oldq = signal(SIGQUIT, SIG_IGN);
		(void) wait((union wait *)&ccode);
		(void) signal(SIGINT, oldi);
		(void) signal(SIGQUIT, oldq);
	} 
	else { /*child*/
		if (chdir(Home) == -1) {
			perror("chdir");
			exit(1);
		}
		(void) execvp(nargv[0], nargv);
		perror("execvp");
		exit(1);
	}
	return(ccode ? 0 : 1);
}

descend(name, fname, exlist)
register struct anode *exlist;
register char *name, *fname;
{
	register DIR *dir;
	register struct direct *dp;
	register char *c1;
	char *endofname;
	char dirname1[MAXPATHLEN +1];
	char dirname2[MAXPATHLEN +1];
	int rv = 0;

	strcpy(dirname1, name);
	strcpy(dirname2, fname);
	if (lstat(fname, &Statb)<0) {
		(void) fprintf(stderr, "find: bad status < %s >\n", name);
		return(0);
	}
	if (!Postorder)		/* 003 GAG */
		(*exlist->F)(exlist);
	if((Statb.st_mode&S_IFMT)!=S_IFDIR) {
		if (Postorder)		/* 003 GAG */
			(*exlist->F)(exlist);
		return(1);
	}
	if((!do_mount) && (mount_dev != Statb.st_dev))
			return(1);

	for (c1 = name; *c1; ++c1);
	if (*(c1-1) == '/')
		--c1;
	endofname = c1;

	if (chdir(fname) == -1)
		return(0);
	if ((dir = opendir(".")) == NULL) {
		(void) fprintf(stderr, "find: cannot open < %s >\n", name);
		rv = 0;
		goto ret;
	}
	for (dp = readdir(dir); dp != NULL; dp = readdir(dir)) {
		if ((dp->d_name[0]=='.' && dp->d_name[1]=='\0') ||
		    (dp->d_name[0]=='.' && dp->d_name[1]=='.'   &&
		     dp->d_name[2]=='\0'))
			continue;
		c1 = endofname;
		*c1++ = '/';
		(void) strcpy(c1, dp->d_name);
		Fname = endofname+1;
		if(!descend(name, Fname, exlist)) {
			*endofname = '\0';
			if (chdir(Home) == -1) {
				perror("chdir");
				exit(1);
			}
			if(chdir(Pathname) == -1) {
				(void) fprintf(stderr,
					"find: bad directory tree\n");
				exit(1);
			}
		}
	}
	rv = 1;
ret:
	if (Postorder) {	/* 003 GAG */
		(void) strcpy(name, dirname1);
		(void) strcpy(fname, dirname2);
		if(stat(".", &Statb) < 0) {
			(void) fprintf(stderr,"cannot stat %s\n", fname);
		}
		(*exlist->F)(exlist);
	}
	if(dir)
		closedir(dir);
	if(chdir("..") == -1) {
		*endofname = '\0';
		(void) fprintf(stderr, "find: bad directory <%s>\n", name);
		rv = 1;
	}
	return(rv);
}

gmatch(s, p) /* string match as in glob */
register char *s, *p;
{
	if (*s=='.' && *p!='.') return(0);
	return(amatch(s, p));
}

amatch(s, p)
register char *s, *p;
{
	register int cc, scc, k, lc;
	int c;

	scc = *s;
	lc = 077777;
	c = *p;
	switch (*p) {

	case '[':
		k = 0;
		while (cc = *++p) {
			switch (cc) {

			case ']':
				if (k)
					return(amatch(++s, ++p));
				else
					return(0);

			case '-':
				k |= lc <= scc & scc <= (cc=p[1]);
			}
			if (scc==(lc=cc)) k++;
		}
		return(0);

	case '?':
caseq:
		if(scc) return(amatch(++s, ++p));
		return(0);
	case '*':
		return(umatch(s, ++p));
	case 0:
		return(!scc);
	}
	if (c==scc) goto caseq;
	return(0);
}

umatch(s, p)
register char *s, *p;
{
	if(*p==0) return(1);
	while(*s)
		if (amatch(s++, p)) return(1);
	return(0);
}

bwrite(rp, c)
register short *rp;
register int c;
{
	register short *wp = Wp;

	c = (c+1) >> 1;
	while(c--) {
		if(!Wct) {
again:
			if(write(Cpio, (char *)Dbuf, Bufsize)<0) {
				Cpio = chgreel(1, Cpio);
				goto again;
			}
			Wct = Bufsize >> 1;
			wp = Dbuf;
			++Blocks;
		}
		*wp++ = *rp++;
		--Wct;
	}
	Wp = wp;
}

chgreel(x, fl)
{
	register int f;
	register FILE *devtty;
	char str[22];
	struct stat statb;
	extern errno;

	(void) fprintf(stderr, "find: errno: %d, ", errno);
	(void) fprintf(stderr,
			"find: can't %s\n", x? "write output": "read input");
	if (fstat(fl, &statb) == -1) {
		perror("fstat");
		exit(1);
	}
	if((statb.st_mode&S_IFMT) != S_IFCHR) {
		(void) fprintf(stderr,"find: not a char dev\n");
		exit(1);
	}
again:
	(void) fprintf(stderr,
		"If you want to go on, type device/file name when ready\n");
	devtty = fopen("/dev/tty", "r");
	if (fgets(str, 20, devtty) == NULL) {
		perror("fgets");
		exit(1);
	}
	str[strlen(str) - 1] = '\0';
	if(!*str) {
		(void) fprintf(stderr,"find: bad string\n");
		exit(1);
	}
	(void) close(fl);
	if((f = open(str, x ? 1 : 0)) < 0) {
		(void) fprintf(stderr, "That didn't work");
		(void) fclose(devtty);
		goto again;
	}
	return(f);
}
/*
 * 003 GAG
 * depth - null function to placate find's parse tree
 */
int
depth()
{
	return (1);
}