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