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->down){
 151                         q->type = QTDIR;
 152                 } else {
 153                         q->type = 0;
 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->mode == 'x')
 223                         d->mode |= 0111;
 224                 if(nd->hash){
 225                         char path[MAXPATH];
 226                         Revlog rl;
 227
 228                         nodepath(seprint(path, path+MAXPATH, ".hg/store/data"), path+MAXPATH, nd);
 229                         if(revlogopen(&rl, path, OREAD) < 0)
 230                                 break;
 231                         if((rev = hashrev(&rl, nd->hash)) >= 0){
 232                                 d->length = rl.map[rev].flen;
 233                                 ri = getrevinfo(rl.map[rev].linkrev);
 234                         }
 235                         revlogclose(&rl);
 236                 }
 237                 break;
 238         }
 239
 240         if(ri){
 241                 d->atime = d->mtime = ri->when;
 242                 d->muid = fsmkuid(ri->who);
 243                 d->uid = fsmkuid(ri->who);
 244         } else
 245                 d->atime = d->mtime = time(0);
 246
 247         if(d->uid == nil)
 248                 d->uid = fsmkuid(nil);
 249         if(d->gid == nil)
 250                 d->gid = fsmkuid(nil);
 251         if(d->muid == nil)
 252                 d->muid = fsmkuid(nil);
 253 }
 254
 255 static void
 256 fsattach(Req *r)
 257 {
 258         Revfile *rf;
 259
 260         if(r->ifcall.aname && r->ifcall.aname[0]){
 261                 respond(r, "invalid attach specifier");
 262                 return;
 263         }
 264         r->fid->qid.path = Qroot;
 265         r->fid->qid.type = QTDIR;
 266         r->fid->qid.vers = 0;
 267         r->ofcall.qid = r->fid->qid;
 268
 269         rf = emalloc9p(sizeof(*rf));
 270         rf->level = Qroot;
 271         rf->info = nil;
 272         rf->tree = nil;
 273         rf->node = nil;
 274
 275         rf->fd = -1;
 276         rf->buf = nil;
 277
 278         r->fid->aux = rf;
 279
 280         respond(r, nil);
 281 }
 282
 283 static void
 284 fsstat(Req *r)
 285 {
 286         Revfile *rf;
 287
 288         rf = r->fid->aux;
 289         if(rf->level < Qtree)
 290                 fsmkdir(&r->d, rf->level,  rf->info);
 291         else
 292                 fsmkdir(&r->d, rf->level,  rf->node);
 293         respond(r, nil);
 294 }
 295
 296 static int
 297 findrev(Revlog *rl, char *name)
 298 {
 299         uchar hash[HASHSZ];
 300         int n, i, rev;
 301         char *s;
 302
 303         if(strcmp(name, "tip") == 0)
 304                 return rl->nmap-1;
 305         rev = strtol(name, &s, 10);
 306         if(s > name && (*s == 0 || ispunct(*s)))
 307                 return rev;
 308         rev = -1;
 309         if(s = strchr(name, '.'))
 310                 name = s+1;
 311         if((n = strhash(name, hash)) > 0){
 312                 for(i=0; i<rl->nmap; i++){
 313                         if(memcmp(rl->map[i].hash, hash, n) == 0){
 314                                 if(rev < 0)
 315                                         rev = i;
 316                                 else {
 317                                         rev = -1;
 318                                         break;
 319                                 }
 320                         }
 321                 }
 322         }
 323         return rev;
 324 }
 325
 326 static char*
 327 fswalk1(Fid *fid, char *name, Qid *qid)
 328 {
 329         Revtree* (*loadfn)(Revlog *, Revlog *, Revinfo *);
 330         Revfile *rf;
 331         Revnode *nd;
 332         int i;
 333
 334         if(!(fid->qid.type&QTDIR))
 335                 return "walk in non-directory";
 336
 337         rf = fid->aux;
 338         if(strcmp(name, "..") == 0){
 339                 switch(rf->level){
 340                 case Qroot:
 341                         break;
 342                 case Qrev:
 343                         rf->info = nil;
 344                         rf->level = Qroot;
 345                         break;
 346                 case Qfiles:
 347                 case Qchanges:
 348                         closerevtree(rf->tree);
 349                         rf->tree = nil;
 350                         rf->level = Qrev;
 351                         break;
 352                 case Qtree:
 353                         if((rf->node = rf->node->up) == rf->tree->root)
 354                                 rf->level = rf->tree->level;
 355                         break;
 356                 }
 357         } else {
 358                 switch(rf->level){
 359                 case Qroot:
 360                         revlogupdate(&changelog);
 361                         revlogupdate(&manifest);
 362
 363                         i = findrev(&changelog, name);
 364                         if(rf->info = getrevinfo(i)){
 365                                 rf->level = Qrev;
 366                                 break;
 367                         }
 368                 Notfound:
 369                         return "directory entry not found";
 370                         break;
 371                 case Qrev:
 372                         for(i = Qrev+1; i < Qtree; i++){
 373                                 if(nametab[i] == nil)
 374                                         continue;
 375                                 if(strcmp(name, nametab[i]) == 0)
 376                                         break;
 377                         }
 378                         loadfn = nil;
 379                         switch(i){
 380                         case Qtree:
 381                                 goto Notfound;
 382                         case Qfiles:
 383                                 loadfn = loadfilestree;
 384                                 break;
 385                         case Qchanges:
 386                                 loadfn = loadchangestree;
 387                                 break;
 388                         }
 389                         if(loadfn){
 390                                 if((rf->tree = getrevtree(loadfn, rf->info)) == nil)
 391                                         goto Notfound;
 392                                 rf->node = rf->tree->root;
 393                                 rf->tree->level = i;
 394                         }
 395                         rf->level = i;
 396                         break;
 397                 case Qtree:
 398                 case Qfiles:
 399                 case Qchanges:
 400                         for(nd = rf->node->down; nd; nd = nd->next)
 401                                 if(strcmp(nd->name, name) == 0)
 402                                         break;
 403                         if(nd == nil)
 404                                 goto Notfound;
 405                         rf->node = nd;
 406                         rf->level = Qtree;
 407                         break;
 408                 }
 409         }
 410
 411         if(rf->level < Qtree)
 412                 fsmkqid(qid, rf->level, rf->info);
 413         else
 414                 fsmkqid(qid, rf->level, rf->node);
 415         fid->qid = *qid;
 416
 417         return nil;
 418 }
 419
 420 static char*
 421 fsclone(Fid *oldfid, Fid *newfid)
 422 {
 423         Revfile *orf, *rf;
 424
 425         rf = nil;
 426         if(orf = oldfid->aux){
 427                 rf = emalloc9p(sizeof(*rf));
 428                 *rf = *orf;
 429                 if(rf->tree)
 430                         incref(rf->tree);
 431                 if(rf->fd >= 0)
 432                         rf->fd = dup(rf->fd, -1);
 433                 if(rf->buf)
 434                         rf->buf = estrdup9p(rf->buf);
 435         }
 436         newfid->aux = rf;
 437         return nil;
 438 }
 439
 440 static void
 441 fsdestroyfid(Fid *fid)
 442 {
 443         Revfile *rf;
 444
 445         if(rf = fid->aux){
 446                 closerevtree(rf->tree);
 447                 if(rf->fd >= 0)
 448                         close(rf->fd);
 449                 free(rf->buf);
 450                 free(rf);
 451         }
 452 }
 453
 454 static void
 455 fsopen(Req *r)
 456 {
 457         Revfile *rf;
 458
 459         rf = r->fid->aux;
 460         switch(r->ifcall.mode & 3){
 461         case OEXEC:
 462                 if(rf->node == nil || rf->node->mode != 'x')
 463                         break;
 464         case OREAD:
 465                 respond(r, nil);
 466                 return;
 467         }
 468         respond(r, "permission denied");
 469 }
 470
 471 static int
 472 rootgen(int i, Dir *d, void *)
 473 {
 474         Revinfo *ri;
 475
 476         if((ri = getrevinfo(i)) == nil)
 477                 return -1;
 478         fsmkdir(d, Qrev, ri);
 479         return 0;
 480 }
 481
 482 static int
 483 revgen(int i, Dir *d, void *aux)
 484 {
 485         i += Qrev+1;
 486         if(i >= Qtree)
 487                 return -1;
 488         fsmkdir(d, i, aux);
 489         return 0;
 490 }
 491
 492 static int
 493 treegen(int i, Dir *d, void *aux)
 494 {
 495         Revnode *nd = aux;
 496
 497         while(i > 0 && nd){
 498                 nd = nd->next;
 499                 i--;
 500         }
 501         if(i || nd == nil)
 502                 return -1;
 503         fsmkdir(d, Qtree, nd);
 504         return 0;
 505 }
 506
 507 static void
 508 fsread(Req *r)
 509 {
 510         Revfile *rf;
 511         char buf[MAXPATH];
 512         Revlog rl;
 513         char *s;
 514         int i, n;
 515
 516         rf = r->fid->aux;
 517         switch(rf->level){
 518         case Qroot:
 519                 revlogupdate(&changelog);
 520                 revlogupdate(&manifest);
 521                 dirread9p(r, rootgen, nil);
 522                 respond(r, nil);
 523                 return;
 524         case Qrev:
 525                 dirread9p(r, revgen, rf->info);
 526                 respond(r, nil);
 527                 return;
 528         case Qrev1:
 529         case Qrev2:
 530                 s = nil;
 531                 if(rf->buf)
 532                         goto Strgen;
 533                 if((i = hashrev(&changelog, rf->info->chash)) >= 0){
 534                         if(rf->level == Qrev1)
 535                                 i = changelog.map[i].p1rev;
 536                         else
 537                                 i = changelog.map[i].p2rev;
 538                         if(i >= 0)
 539                                 snprint(s = buf, sizeof(buf), "%d.%H", i, changelog.map[i].hash);
 540                 }
 541                 goto Strgen;
 542         case Qlog:
 543                 if(rf->fd >= 0)
 544                         goto Fdgen;
 545                 if((rf->fd = revlogopentemp(&changelog, hashrev(&changelog, rf->info->chash))) < 0){
 546                         responderror(r);
 547                         return;
 548                 }
 549                 goto Fdgen;
 550         case Qwho:
 551                 s = rf->info->who;
 552                 goto Strgen;
 553         case Qwhy:
 554                 s = rf->info->why;
 555         Strgen:
 556                 if(rf->buf == nil)
 557                         rf->buf = s ? smprint("%s\n", s) : estrdup9p("");
 558                 readstr(r, rf->buf);
 559                 respond(r, nil);
 560                 return;
 561         case Qtree:
 562                 if(rf->node->down){
 563         case Qfiles:
 564         case Qchanges:
 565                         dirread9p(r, treegen, rf->node->down);
 566                         respond(r, nil);
 567                         return;
 568                 }
 569                 if(rf->fd >= 0)
 570                         goto Fdgen;
 571                 nodepath(seprint(buf, buf+sizeof(buf), ".hg/store/data"), buf+sizeof(buf), rf->node);
 572                 if(revlogopen(&rl, buf, OREAD) < 0){
 573                         responderror(r);
 574                         return;
 575                 }
 576                 if((rf->fd = revlogopentemp(&rl, hashrev(&rl, rf->node->hash))) < 0){
 577                         responderror(r);
 578                         revlogclose(&rl);
 579                         return;
 580                 }
 581                 revlogclose(&rl);
 582         Fdgen:
 583                 if((n = pread(rf->fd, r->ofcall.data, r->ifcall.count, r->ifcall.offset)) < 0){
 584                         responderror(r);
 585                         return;
 586                 }
 587                 r->ofcall.count = n;
 588                 respond(r, nil);
 589                 return;
 590         }
 591         respond(r, "bug in fsread");
 592 }
 593
 594 Srv fs =
 595 {
 596         .attach=fsattach,
 597         .stat=fsstat,
 598         .walk1=fswalk1,
 599         .clone=fsclone,
 600         .destroyfid=fsdestroyfid,
 601         .open=fsopen,
 602         .read=fsread,
 603 };
 604
 605 void
 606 usage(void)
 607 {
 608         fprint(2, "usage: %s [-D] [-m mtpt] [-s srv]\n", argv0);
 609         exits("usage");
 610 }
 611
 612 void
 613 main(int argc, char *argv[])
 614 {
 615         char *srv, *mtpt;
 616
 617         inflateinit();
 618         fmtinstall('H', Hfmt);
 619
 620         srv = nil;
 621         mtpt = "/n/hg";
 622
 623         ARGBEGIN {
 624         case 'D':
 625                 chatty9p++;
 626                 break;
 627         case 'm':
 628                 mtpt = EARGF(usage());
 629                 break;
 630         case 's':
 631                 srv = EARGF(usage());
 632                 break;
 633         default:
 634                 usage();
 635         } ARGEND;
 636
 637         if(revlogopen(&changelog, ".hg/store/00changelog", OREAD) < 0)
 638                 sysfatal("can't open changelog: %r\n");
 639         if(revlogopen(&manifest, ".hg/store/00manifest", OREAD) < 0)
 640                 sysfatal("can't open menifest: %r\n");
 641
 642         postmountsrv(&fs, srv, mtpt, MREPL);
 643 }