sys/src/cmd/hgfs/fs.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <thread.h>
   4 #include "dat.h"
   5 #include "fns.h"
   6
   7 #include <ctype.h>
   8 #include <flate.h>
   9 #include <auth.h>
  10 #include <fcall.h>
  11 #include <9p.h>
  12
  13 enum {
  14         Qroot,
  15                 Qrev,
  16                         Qrev1,
  17                         Qrev2,
  18                         Qlog,
  19                         Qwho,
  20                         Qwhy,
  21                         Qfiles,
  22                         Qchanges,
  23                                 Qtree,
  24 };
  25
  26 static char *nametab[Qtree+1] = {
  27         "/",
  28                 nil,
  29                         "rev1",
  30                         "rev2",
  31                         "log",
  32                         "who",
  33                         "why",
  34                         "files",
  35                         "changes",
  36                                 nil,
  37 };
  38
  39 static Revlog changelog;
  40 static Revlog manifest;
  41
  42 static Revinfo*
  43 getrevinfo(int rev)
  44 {
  45         Revinfo *ri;
  46
  47         if(rev < 0 || rev >= changelog.nmap)
  48                 return nil;
  49         if(ri = changelog.map[rev].aux)
  50                 return ri;
  51         if(ri = loadrevinfo(&changelog, rev))
  52                 changelog.map[rev].aux = ri;
  53         return ri;
  54 }
  55
  56 static Revtree*
  57 getrevtree(Revtree *(*fn)(Revlog *, Revlog *, Revinfo *), Revinfo *ri)
  58 {
  59         static ulong gen;
  60         static struct {
  61                 ulong g;
  62                 void *f;
  63                 Revinfo *i;
  64                 Revtree *t;
  65         } cache[4];
  66         Revtree *rt;
  67         int i, j;
  68
  69         for(i=j=0; i<nelem(cache); i++){
  70                 if(cache[i].t == nil){
  71                         j = i;
  72                         continue;
  73                 }
  74                 if(cache[i].f == fn && cache[i].i == ri){
  75                         cache[i].g = ++gen;
  76                         rt = cache[i].t;
  77                         goto found;
  78                 }
  79                 if(cache[j].t && cache[i].g < cache[j].g)
  80                         j = i;
  81         }
  82         if((rt = (*fn)(&changelog, &manifest, ri)) == nil)
  83                 return nil;
  84
  85         closerevtree(cache[j].t);
  86
  87         cache[j].g = ++gen;
  88         cache[j].f = fn;
  89         cache[j].i = ri;
  90         cache[j].t = rt;
  91
  92 found:
  93         incref(rt);
  94         return rt;
  95 }
  96
  97 static char*
  98 fsmkuid(char *s)
  99 {
 100         if(s){
 101                 char *x;
 102
 103                 while(x = strchr(s, '<'))
 104                         s = x+1;
 105                 s = estrdup9p(s);
 106                 if(x = strchr(s, '>'))
 107                         *x = 0;
 108                 if(x = strchr(s, '@'))
 109                         *x = 0;
 110                 if(x = strchr(s, '\n'))
 111                         *x = 0;
 112         }
 113         if(s == nil || *s == 0){
 114                 free(s);
 115                 s = estrdup9p("hgfs");
 116         }
 117         return s;
 118 }
 119
 120 static void
 121 fsmkqid(Qid *q, int level, void *aux)
 122 {
 123         Revnode *nd;
 124         Revinfo *ri;
 125
 126         switch(level){
 127         case Qroot:
 128                 q->type = QTDIR;
 129                 q->path = Qroot;
 130                 q->vers = 0;
 131                 break;
 132         case Qrev:
 133         case Qfiles:
 134         case Qchanges:
 135                 q->type = QTDIR;
 136                 if(0){
 137         case Qrev1:
 138         case Qrev2:
 139         case Qlog:
 140         case Qwho:
 141         case Qwhy:
 142                 q->type = 0;
 143                 }
 144                 ri = aux;
 145                 q->path = *((uvlong*)ri->chash) + (level - Qrev);
 146                 q->vers = 0;
 147                 break;
 148         case Qtree:
 149                 nd = aux;
 150                 if(nd->hash){
 151                         q->type = 0;
 152                 } else {
 153                         q->type = QTDIR;
 154                 }
 155                 q->path = nd->path;
 156                 q->vers = 0;
 157                 break;
 158         }
 159 }
 160
 161 static void
 162 fsmkdir(Dir *d, int level, void *aux)
 163 {
 164         char buf[64], *s;
 165         Revnode *nd;
 166         Revinfo *ri;
 167         int rev;
 168
 169         memset(d, 0, sizeof(*d));
 170
 171         fsmkqid(&d->qid, level, aux);
 172
 173         d->mode = 0444;
 174         if(d->qid.type == QTDIR)
 175                 d->mode |= DMDIR | 0111;
 176
 177         s = nil;
 178         ri = nil;
 179         switch(level){
 180         case Qroot:
 181                 goto Namegen;
 182         case Qrev:
 183         case Qrev1:
 184         case Qrev2:
 185                 ri = aux;
 186                 rev = hashrev(&changelog, ri->chash);
 187                 if(level == Qrev1)
 188                         rev = changelog.map[rev].p1rev;
 189                 else if(level == Qrev2)
 190                         rev = changelog.map[rev].p2rev;
 191                 if(rev >= 0)
 192                         snprint(s = buf, sizeof(buf), "%d.%H", rev, changelog.map[rev].hash);
 193                 if(level == Qrev){
 194                         d->name = estrdup9p(buf);
 195                         break;
 196                 }
 197                 goto Strgen;
 198         case Qlog:
 199                 ri = aux;
 200                 if((rev = hashrev(&changelog, ri->chash)) >= 0)
 201                         d->length = changelog.map[rev].flen;
 202                 goto Namegen;
 203         case Qwho:
 204                 ri = aux;
 205                 s = ri->who;
 206                 goto Strgen;
 207         case Qwhy:
 208                 ri = aux;
 209                 s = ri->why;
 210         Strgen:
 211                 d->length = s ? strlen(s)+1 : 0;
 212         case Qfiles:
 213         case Qchanges:
 214                 ri = aux;
 215                 /* no break */
 216         Namegen:
 217                 d->name = estrdup9p(nametab[level]);
 218                 break;
 219         case Qtree:
 220                 nd = aux;
 221                 d->name = estrdup9p(nd->name);
 222                 if(nd->hash){
 223                         char path[MAXPATH];
 224                         Revlog rl;
 225
 226                         nodepath(seprint(path, path+MAXPATH, ".hg/store/data"), path+MAXPATH, nd);
 227                         if(revlogopen(&rl, path, OREAD) < 0)
 228                                 break;
 229                         if((rev = hashrev(&rl, nd->hash)) >= 0){
 230                                 d->length = rl.map[rev].flen;
 231                                 ri = getrevinfo(rl.map[rev].linkrev);
 232                         }
 233                         revlogclose(&rl);
 234                 }
 235                 break;
 236         }
 237
 238         if(ri){
 239                 d->atime = d->mtime = ri->when;
 240                 d->muid = fsmkuid(ri->who);
 241                 d->uid = fsmkuid(ri->who);
 242         } else
 243                 d->atime = d->mtime = time(0);
 244
 245         if(d->uid == nil)
 246                 d->uid = fsmkuid(nil);
 247         if(d->gid == nil)
 248                 d->gid = fsmkuid(nil);
 249         if(d->muid == nil)
 250                 d->muid = fsmkuid(nil);
 251 }
 252
 253 static void
 254 fsattach(Req *r)
 255 {
 256         Revfile *rf;
 257
 258         if(r->ifcall.aname && r->ifcall.aname[0]){
 259                 respond(r, "invalid attach specifier");
 260                 return;
 261         }
 262         r->fid->qid.path = Qroot;
 263         r->fid->qid.type = QTDIR;
 264         r->fid->qid.vers = 0;
 265         r->ofcall.qid = r->fid->qid;
 266
 267         rf = emalloc9p(sizeof(*rf));
 268         rf->level = Qroot;
 269         rf->info = nil;
 270         rf->tree = nil;
 271         rf->node = nil;
 272
 273         rf->fd = -1;
 274         rf->buf = nil;
 275
 276         r->fid->aux = rf;
 277
 278         respond(r, nil);
 279 }
 280
 281 static void
 282 fsstat(Req *r)
 283 {
 284         Revfile *rf;
 285
 286         rf = r->fid->aux;
 287         if(rf->level < Qtree)
 288                 fsmkdir(&r->d, rf->level,  rf->info);
 289         else
 290                 fsmkdir(&r->d, rf->level,  rf->node);
 291         respond(r, nil);
 292 }
 293
 294 static int
 295 findrev(Revlog *rl, char *name)
 296 {
 297         uchar hash[HASHSZ];
 298         int n, i, rev;
 299         char *s;
 300
 301         rev = strtol(name, &s, 10);
 302         if(s > name && (*s == 0 || ispunct(*s)))
 303                 return rev;
 304         rev = -1;
 305         if(s = strchr(name, '.'))
 306                 name = s+1;
 307         if((n = strhash(name, hash)) > 0){
 308                 for(i=0; i<rl->nmap; i++){
 309                         if(memcmp(rl->map[i].hash, hash, n) == 0){
 310                                 if(rev < 0)
 311                                         rev = i;
 312                                 else {
 313                                         rev = -1;
 314                                         break;
 315                                 }
 316                         }
 317                 }
 318         }
 319         return rev;
 320 }
 321
 322 static char*
 323 fswalk1(Fid *fid, char *name, Qid *qid)
 324 {
 325         Revtree* (*loadfn)(Revlog *, Revlog *, Revinfo *);
 326         Revfile *rf;
 327         Revnode *nd;
 328         int i;
 329
 330         if(!(fid->qid.type&QTDIR))
 331                 return "walk in non-directory";
 332
 333         rf = fid->aux;
 334         if(strcmp(name, "..") == 0){
 335                 switch(rf->level){
 336                 case Qroot:
 337                         break;
 338                 case Qrev:
 339                         rf->info = nil;
 340                         rf->level = Qroot;
 341                         break;
 342                 case Qfiles:
 343                 case Qchanges:
 344                         closerevtree(rf->tree);
 345                         rf->tree = nil;
 346                         rf->level = Qrev;
 347                         break;
 348                 case Qtree:
 349                         if((rf->node = rf->node->up) == rf->tree->root)
 350                                 rf->level = rf->tree->level;
 351                         break;
 352                 }
 353         } else {
 354                 switch(rf->level){
 355                 case Qroot:
 356                         revlogupdate(&changelog);
 357                         revlogupdate(&manifest);
 358
 359                         i = findrev(&changelog, name);
 360                         if(rf->info = getrevinfo(i)){
 361                                 rf->level = Qrev;
 362                                 break;
 363                         }
 364                 Notfound:
 365                         return "directory entry not found";
 366                         break;
 367                 case Qrev:
 368                         for(i = Qrev+1; i < Qtree; i++){
 369                                 if(nametab[i] == nil)
 370                                         continue;
 371                                 if(strcmp(name, nametab[i]) == 0)
 372                                         break;
 373                         }
 374                         loadfn = nil;
 375                         switch(i){
 376                         case Qtree:
 377                                 goto Notfound;
 378                         case Qfiles:
 379                                 loadfn = loadfilestree;
 380                                 break;
 381                         case Qchanges:
 382                                 loadfn = loadchangestree;
 383                                 break;
 384                         }
 385                         if(loadfn){
 386                                 if((rf->tree = getrevtree(loadfn, rf->info)) == nil)
 387                                         goto Notfound;
 388                                 rf->node = rf->tree->root;
 389                                 rf->tree->level = i;
 390                         }
 391                         rf->level = i;
 392                         break;
 393                 case Qtree:
 394                 case Qfiles:
 395                 case Qchanges:
 396                         for(nd = rf->node->down; nd; nd = nd->next)
 397                                 if(strcmp(nd->name, name) == 0)
 398                                         break;
 399                         if(nd == nil)
 400                                 goto Notfound;
 401                         rf->node = nd;
 402                         rf->level = Qtree;
 403                         break;
 404                 }
 405         }
 406
 407         if(rf->level < Qtree)
 408                 fsmkqid(qid, rf->level, rf->info);
 409         else
 410                 fsmkqid(qid, rf->level, rf->node);
 411         fid->qid = *qid;
 412
 413         return nil;
 414 }
 415
 416 static char*
 417 fsclone(Fid *oldfid, Fid *newfid)
 418 {
 419         Revfile *orf, *rf;
 420
 421         rf = nil;
 422         if(orf = oldfid->aux){
 423                 rf = emalloc9p(sizeof(*rf));
 424                 *rf = *orf;
 425                 if(rf->tree)
 426                         incref(rf->tree);
 427                 if(rf->fd >= 0)
 428                         rf->fd = dup(rf->fd, -1);
 429                 if(rf->buf)
 430                         rf->buf = estrdup9p(rf->buf);
 431         }
 432         newfid->aux = rf;
 433         return nil;
 434 }
 435
 436 static void
 437 fsdestroyfid(Fid *fid)
 438 {
 439         Revfile *rf;
 440
 441         if(rf = fid->aux){
 442                 closerevtree(rf->tree);
 443                 if(rf->fd >= 0)
 444                         close(rf->fd);
 445                 free(rf->buf);
 446                 free(rf);
 447         }
 448 }
 449
 450 static void
 451 fsopen(Req *r)
 452 {
 453         respond(r, nil);
 454 }
 455
 456 static int
 457 rootgen(int i, Dir *d, void *)
 458 {
 459         Revinfo *ri;
 460
 461         if((ri = getrevinfo(i)) == nil)
 462                 return -1;
 463         fsmkdir(d, Qrev, ri);
 464         return 0;
 465 }
 466
 467 static int
 468 revgen(int i, Dir *d, void *aux)
 469 {
 470         i += Qrev+1;
 471         if(i >= Qtree)
 472                 return -1;
 473         fsmkdir(d, i, aux);
 474         return 0;
 475 }
 476
 477 static int
 478 treegen(int i, Dir *d, void *aux)
 479 {
 480         Revnode *nd = aux;
 481
 482         while(i > 0 && nd){
 483                 nd = nd->next;
 484                 i--;
 485         }
 486         if(i || nd == nil)
 487                 return -1;
 488         fsmkdir(d, Qtree, nd);
 489         return 0;
 490 }
 491
 492 static void
 493 fsread(Req *r)
 494 {
 495         Revfile *rf;
 496
 497         rf = r->fid->aux;
 498         if(r->fid->qid.type == QTDIR){
 499                 switch(rf->level){
 500                 default:
 501                         respond(r, "bug in fsread");
 502                         return;
 503                 case Qroot:
 504                         revlogupdate(&changelog);
 505                         revlogupdate(&manifest);
 506
 507                         dirread9p(r, rootgen, nil);
 508                         respond(r, nil);
 509                         return;
 510                 case Qrev:
 511                         dirread9p(r, revgen, rf->info);
 512                         respond(r, nil);
 513                         return;
 514                 case Qtree:
 515                 case Qfiles:
 516                 case Qchanges:
 517                         dirread9p(r, treegen, rf->node->down);
 518                         respond(r, nil);
 519                         return;
 520                 }
 521         } else {
 522                 char buf[MAXPATH];
 523                 Revlog rl;
 524                 char *s;
 525                 int i, n;
 526
 527                 switch(rf->level){
 528                 default:
 529                         respond(r, "bug in fsread");
 530                         return;
 531                 case Qlog:
 532                         if(rf->fd >= 0)
 533                                 break;
 534                         if((rf->fd = revlogopentemp(&changelog, hashrev(&changelog, rf->info->chash))) < 0){
 535                                 responderror(r);
 536                                 return;
 537                         }
 538                         break;
 539                 case Qrev1:
 540                 case Qrev2:
 541                         s = nil;
 542                         if((i = hashrev(&changelog, rf->info->chash)) >= 0){
 543                                 if(rf->level == Qrev1)
 544                                         i = changelog.map[i].p1rev;
 545                                 else
 546                                         i = changelog.map[i].p2rev;
 547                                 if(i >= 0)
 548                                         snprint(s = buf, sizeof(buf), "%d.%H", i, changelog.map[i].hash);
 549                         }
 550                         goto Strgen;
 551                 case Qwho:
 552                         s = rf->info->who;
 553                         goto Strgen;
 554                 case Qwhy:
 555                         s = rf->info->why;
 556                 Strgen:
 557                         if(rf->buf == nil)
 558                                 rf->buf = s ? smprint("%s\n", s) : estrdup9p("");
 559                         readstr(r, rf->buf);
 560                         respond(r, nil);
 561                         return;
 562                 case Qtree:
 563                         if(rf->fd >= 0)
 564                                 break;
 565                         nodepath(seprint(buf, buf+sizeof(buf), ".hg/store/data"), buf+sizeof(buf), rf->node);
 566                         if(revlogopen(&rl, buf, OREAD) < 0){
 567                                 responderror(r);
 568                                 return;
 569                         }
 570                         if((rf->fd = revlogopentemp(&rl, hashrev(&rl, rf->node->hash))) < 0){
 571                                 responderror(r);
 572                                 revlogclose(&rl);
 573                                 return;
 574                         }
 575                         revlogclose(&rl);
 576                         break;
 577                 }
 578                 if((n = pread(rf->fd, r->ofcall.data, r->ifcall.count, r->ifcall.offset)) < 0){
 579                         responderror(r);
 580                         return;
 581                 }
 582                 r->ofcall.count = n;
 583                 respond(r, nil);
 584         }
 585 }
 586
 587 Srv fs =
 588 {
 589         .attach=fsattach,
 590         .stat=fsstat,
 591         .walk1=fswalk1,
 592         .clone=fsclone,
 593         .destroyfid=fsdestroyfid,
 594         .open=fsopen,
 595         .read=fsread,
 596 };
 597
 598 void
 599 usage(void)
 600 {
 601         fprint(2, "usage: %s [-D] [-m mtpt] [-s srv]\n", argv0);
 602         exits("usage");
 603 }
 604
 605 void
 606 main(int argc, char *argv[])
 607 {
 608         char *srv, *mtpt;
 609
 610         inflateinit();
 611         fmtinstall('H', Hfmt);
 612
 613         srv = nil;
 614         mtpt = "/n/hg";
 615
 616         ARGBEGIN {
 617         case 'D':
 618                 chatty9p++;
 619                 break;
 620         case 'm':
 621                 mtpt = EARGF(usage());
 622                 break;
 623         case 's':
 624                 srv = EARGF(usage());
 625                 break;
 626         default:
 627                 usage();
 628         } ARGEND;
 629
 630         if(revlogopen(&changelog, ".hg/store/00changelog", OREAD) < 0)
 631                 sysfatal("can't open changelog: %r\n");
 632         if(revlogopen(&manifest, ".hg/store/00manifest", OREAD) < 0)
 633                 sysfatal("can't open menifest: %r\n");
 634
 635         postmountsrv(&fs, srv, mtpt, MREPL);
 636 }