ref: a79465e118a0469bbda928f86b9eef6b42d18593
dir: /sys/src/cmd/derp.c/
#include <u.h>
#include <libc.h>
int permcheck = 0;
int usercheck = 0;
int dumpcheck = 1;
int sizecheck = 1;
int timecheck = 0;
int quiet = 0;
int errors = 0;
int noerror = 0;
void
error(char *fmt, ...)
{
char buf[ERRMAX];
va_list a;
errors++;
if(!quiet){
va_start(a, fmt);
vsnprint(buf, sizeof(buf), fmt, a);
va_end(a);
fprint(2, "%s: %s\n", argv0, buf);
}
if(!noerror)
exits("errors");
}
#pragma varargck argpos error 1
void*
emalloc(int n)
{
void *v;
if((v = malloc(n)) == nil){
noerror = 0;
error("out of memory");
}
return v;
}
enum {
BUFSIZE = 8*1024,
};
int
cmpfile(char *a, char *b)
{
static uchar buf1[BUFSIZE], buf2[BUFSIZE];
int r, n, m, fd1, fd2;
if((fd1 = open(a, OREAD)) < 0)
error("can't open %s: %r", a);
if((fd2 = open(b, OREAD)) < 0)
error("can't open %s: %r", b);
r = fd1 != fd2;
if(fd1 >= 0 && fd2 >= 0)
do{
if((n = readn(fd1, buf1, sizeof(buf1))) < 0){
error("can't read %s: %r", a);
break;
}
m = n;
if(m == 0)
m++; /* read past eof to verify size */
if((m = readn(fd2, buf2, m)) < 0){
error("can't read %s: %r", b);
break;
}
if(m != n)
break;
if(n == 0){
r = 0;
break;
}
} while(memcmp(buf1, buf2, n) == 0);
if(fd1 >= 0)
close(fd1);
if(fd2 >= 0)
close(fd2);
return r;
}
int
samefile(Dir *a, Dir *b)
{
if(a == b)
return 1;
if(a->type == b->type && a->dev == b->dev &&
a->qid.type == b->qid.type &&
a->qid.path == b->qid.path &&
a->qid.vers == b->qid.vers){
if((a->qid.type & QTDIR) == 0)
return 1;
/*
* directories in /n/dump have the same qid, but
* atime can be used to skip potentially
* untouched subtrees.
*/
if(dumpcheck && a->atime == b->atime)
return 1;
}
return 0;
}
int
dcmp(Dir *a, Dir *b)
{
if(a == nil || b == nil)
return a != b;
if(samefile(a, b))
return 0;
if((a->qid.type | b->qid.type) & QTDIR)
return 1;
if((a->mode ^ b->mode) & permcheck)
return 1;
if(usercheck){
if(strcmp(a->uid, b->uid) != 0)
return 1;
if(strcmp(a->gid, b->gid) != 0)
return 1;
}
if(sizecheck)
if(a->length != b->length)
return 1;
if(timecheck)
if(a->mtime != b->mtime)
return 1;
if(sizecheck && timecheck)
return 0;
return cmpfile(a->name, b->name);
}
Dir*
statdir(char *path)
{
Dir *d;
d = dirstat(path);
if(d == nil)
error("can't stat %s: %r", path);
else {
d->name = emalloc(strlen(path)+1);
strcpy(d->name, path);
}
return d;
}
char*
pjoin(char *path, char *name)
{
char *s;
int n;
n = strlen(path);
s = emalloc(n+strlen(name)+2);
strcpy(s, path);
if(path[0] != '\0' && path[n-1] != '/')
s[n++] = '/';
strcpy(s+n, name);
return s;
}
Dir*
absdir(Dir *d, char *path)
{
if(d != nil)
d->name = pjoin(path, d->name);
return d;
}
void
cleardir(Dir *d)
{
if(d != nil){
free(d->name);
d->name = "";
}
}
void
freedir(Dir *d)
{
cleardir(d);
free(d);
}
int
dnamecmp(void *a, void *b)
{
return strcmp(((Dir*)a)->name, ((Dir*)b)->name);
}
int
readifdir(Dir **dp)
{
int n, fd;
Dir *d;
d = *dp;
*dp = nil;
if(d == nil || (d->qid.type & QTDIR) == 0)
return 0;
fd = open(d->name, OREAD);
if(fd < 0){
error("can't open %s: %r", d->name);
return -1;
}
if((n = dirreadall(fd, dp)) < 0)
error("can't read %s: %r", d->name);
close(fd);
if(n > 1)
qsort(*dp, n, sizeof(Dir), dnamecmp);
return n;
}
void
diffgen(Dir *ld, Dir *rd, Dir *ad, char *path);
void
diffdir(Dir *ld, Dir *rd, Dir *ad, char *path)
{
int n, m, o, i, j, k, t, v;
char *sp, *lp, *rp, *ap;
Dir *od;
lp = rp = ap = nil;
if(ld != nil)
lp = ld->name;
if(rd != nil)
rp = rd->name;
if(ad != nil){
/* check if ad is the same as ld or rd */
if(ld != nil && samefile(ad, ld)){
ap = ld->name;
ad = nil; /* don't read directory twice */
}
else if(rd != nil && samefile(ad, rd)){
ap = rd->name;
ad = nil; /* don't read directory twice */
}
else
ap = ad->name;
}
n = readifdir(&ld);
m = readifdir(&rd);
if(n <= 0 && m <= 0)
return;
/* at least one side is directory */
o = readifdir(&ad);
i = j = k = 0;
for(;;){
if(i < n)
t = (j < m) ? strcmp(ld[i].name, rd[j].name) : -1;
else if(j < m)
t = 1;
else
break;
od = nil;
if(t < 0){
sp = pjoin(path, ld[i].name);
if(ap == lp)
od = &ld[i];
else while(k < o){
v = strcmp(ad[k].name, ld[i].name);
if(v == 0){
od = absdir(&ad[k++], ap);
break;
} else if(v > 0)
break;
k++;
}
diffgen(absdir(&ld[i], lp), nil, od, sp);
cleardir(&ld[i]);
if(&ld[i] == od)
od = nil;
i++;
} else {
sp = pjoin(path, rd[j].name);
if(ap == rp)
od = &rd[j];
else while(k < o){
v = strcmp(ad[k].name, rd[j].name);
if(v == 0){
od = absdir(&ad[k++], ap);
break;
} else if(v > 0)
break;
k++;
}
if(t > 0)
diffgen(nil, absdir(&rd[j], rp), od, sp);
else {
if(ap == lp)
od = &ld[i];
diffgen(absdir(&ld[i], lp), absdir(&rd[j], rp), od, sp);
cleardir(&ld[i]);
if(&ld[i] == od)
od = nil;
i++;
}
cleardir(&rd[j]);
if(&rd[j] == od)
od = nil;
j++;
}
cleardir(od);
free(sp);
}
free(ld);
free(rd);
free(ad);
}
void
diffgen(Dir *ld, Dir *rd, Dir *ad, char *path)
{
if(dcmp(ld, rd) == 0)
return;
if(ld == nil || rd == nil){
/* one side doesnt exit anymore */
if(ad != nil){
/* existed before, is deletion */
if(ld != nil && (ad->qid.type & QTDIR) && (ld->qid.type & QTDIR)){
/* remote deleted direcotry, remote newer */
diffdir(ld, nil, ad, path);
print("nd\t%s\n", path);
return;
} else if(rd != nil && (ad->qid.type & QTDIR) && (rd->qid.type & QTDIR)){
/* local deleted direcotry, local newer */
diffdir(nil, rd, ad, path);
print("dn\t%s\n", path);
return;
} else if(dcmp(rd, ad) == 0){
/* local deleted file, local newer */
print("dn\t%s\n", path);
} else if(dcmp(ld, ad) == 0){
/* remote deleted file, remote newer */
print("nd\t%s\n", path);
} else if(ld != nil){
if((ld->qid.type ^ ad->qid.type) & QTDIR){
/* local file type change, remote deleted, no conflict */
diffgen(ld, nil, nil, path);
return;
}
/* local modified, remote deleted, conflict */
print("md!\t%s\n", path);
return;
} else {
if((rd->qid.type ^ ad->qid.type) & QTDIR){
/* remote file type change, local deleted, no conflict */
diffgen(nil, rd, nil, path);
return;
}
/* remote modified, local deleted, conflict */
print("dm!\t%s\n", path);
return;
}
} else {
/* didnt exist before, is addition */
if(ld != nil){
/* local added file, local newer */
print("an\t%s\n", path);
} else {
/* remote added file, remote newer */
print("na\t%s\n", path);
}
}
} else {
if(ad != nil){
/* existed before, is modification */
if((ad->qid.type & QTDIR) && (ld->qid.type & QTDIR) && (rd->qid.type & QTDIR)){
/* all still directories, no problem */
} else if(dcmp(rd, ad) == 0){
if((ld->qid.type ^ ad->qid.type) & QTDIR){
/* local file type change */
diffgen(nil, ad, ad, path);
diffgen(ld, nil, nil, path);
return;
}
/* local modified file, local newer */
print("mn\t%s\n", path);
} else if(dcmp(ld, ad) == 0){
if((rd->qid.type ^ ad->qid.type) & QTDIR){
/* remote file type change */
diffgen(ad, nil, ad, path);
diffgen(nil, rd, nil, path);
return;
}
/* remote modified file, remote newer */
print("nm\t%s\n", path);
} else {
if((ld->qid.type & QTDIR) != (ad->qid.type & QTDIR) &&
(rd->qid.type & QTDIR) != (ad->qid.type & QTDIR) &&
(ld->qid.type & QTDIR) == (rd->qid.type & QTDIR)){
if((ad->qid.type & QTDIR) == 0){
/* local and remote became directories, was file before */
diffdir(ld, rd, nil, path);
} else {
/* local and remote became diverging files, conflict */
print("aa!\t%s\n", path);
}
} else {
/* local and remote modified, conflict */
print("mm!\t%s\n", path);
}
return;
}
} else {
/* didnt exist before, is addition from both */
if((ld->qid.type & QTDIR) && (rd->qid.type & QTDIR)){
/* local and remote added directories, no problem */
} else {
/* local and remote added diverging files, conflict */
print("aa!\t%s\n", path);
return;
}
}
}
diffdir(ld, rd, ad, path);
}
void
diff3(char *lp, char *ap, char *rp)
{
Dir *ld, *rd, *ad;
ad = nil;
ld = statdir(lp);
rd = statdir(rp);
if(ld == nil && rd == nil)
goto Out;
else if(strcmp(ap, lp) == 0)
ad = ld;
else if(strcmp(ap, rp) == 0)
ad = rd;
else if((ad = statdir(ap)) != nil){
if(ld != nil && samefile(ad, ld)){
freedir(ad);
ad = ld;
}
else if(rd != nil && samefile(ad, rd)){
freedir(ad);
ad = rd;
}
}
diffgen(ld, rd, ad, "");
Out:
freedir(ld);
freedir(rd);
if(ad != nil && ad != ld && ad != rd)
freedir(ad);
}
void
usage(void)
{
fprint(2, "usage: %s [ -qcutDL ] [ -p perms ] myfile oldfile yourfile\n", argv0);
exits("usage");
}
void
main(int argc, char *argv[])
{
ARGBEGIN {
case 'q':
quiet = 1;
break;
case 'c':
noerror = 1;
break;
case 'u':
usercheck = 1;
break;
case 't':
timecheck = 1;
break;
case 'D':
dumpcheck = 0;
break;
case 'L':
sizecheck = 0;
break;
case 'p':
permcheck = strtol(EARGF(usage()), nil, 8) & 0777;
break;
default:
usage();
} ARGEND;
if(argc != 3)
usage();
diff3(argv[0], argv[1], argv[2]);
if(errors)
exits("errors");
exits(0);
}