sys/src/cmd/9660srv/9660srv.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <auth.h>
   4 #include <fcall.h>
   5 #include "dat.h"
   6 #include "fns.h"
   7 #include "iso9660.h"
   8
   9 static void     ireset(void);
  10 static int      iattach(Xfile*);
  11 static void     iclone(Xfile*, Xfile*);
  12 static void     iwalkup(Xfile*);
  13 static void     iwalk(Xfile*, char*);
  14 static void     iopen(Xfile*, int);
  15 static void     icreate(Xfile*, char*, long, int);
  16 static long     ireaddir(Xfile*, uchar*, vlong, long);
  17 static long     iread(Xfile*, char*, vlong, long);
  18 static long     iwrite(Xfile*, char*, vlong, long);
  19 static void     iclunk(Xfile*);
  20 static void     iremove(Xfile*);
  21 static void     istat(Xfile*, Dir*);
  22 static void     iwstat(Xfile*, Dir*);
  23
  24 static char*    nstr(uchar*, int);
  25 static char*    rdate(uchar*, int);
  26 static int      getcontin(Xdata*, uchar*, uchar**);
  27 static int      getdrec(Xfile*, void*);
  28 static void     ungetdrec(Xfile*);
  29 static int      opendotdot(Xfile*, Xfile*);
  30 static int      showdrec(int, int, void*);
  31 static long     gtime(uchar*);
  32 static long     l16(void*);
  33 static long     l32(void*);
  34 static void     newdrec(Xfile*, Drec*);
  35 static int      rzdir(Xfs*, Dir*, int, Drec*);
  36
  37 Xfsub   isosub =
  38 {
  39         ireset, iattach, iclone, iwalkup, iwalk, iopen, icreate,
  40         ireaddir, iread, iwrite, iclunk, iremove, istat, iwstat
  41 };
  42
  43 static vlong
  44 fakemax(vlong len)
  45 {
  46         if(len == (1UL << 31) - 1)      /* max. 9660 size? */
  47                 len = (1ULL << 63) - 1; /* pretend it's vast */
  48         return len;
  49 }
  50
  51 static void
  52 ireset(void)
  53 {}
  54
  55 static int
  56 iattach(Xfile *root)
  57 {
  58         Xfs *cd = root->xf;
  59         Iobuf *p; Voldesc *v; Isofile *fp; Drec *dp;
  60         int fmt, blksize, i, n, l, haveplan9;
  61         Iobuf *dirp;
  62         uchar dbuf[256];
  63         Drec *rd = (Drec *)dbuf;
  64         uchar *q, *s;
  65
  66         dirp = nil;
  67         blksize = 0;
  68         fmt = 0;
  69         dp = nil;
  70         haveplan9 = 0;
  71         for(i=VOLDESC;i<VOLDESC+100; i++){      /* +100 for sanity */
  72                 p = getbuf(cd->d, i, 1);
  73                 v = (Voldesc*)(p->iobuf);
  74                 if(memcmp(v->byte, "\01CD001\01", 7) == 0){             /* iso */
  75                         if(dirp)
  76                                 putbuf(dirp);
  77                         dirp = p;
  78                         fmt = 'z';
  79                         dp = (Drec*)v->z.desc.rootdir;
  80                         blksize = l16(v->z.desc.blksize);
  81                         chat("iso, blksize=%d...", blksize);
  82
  83                         v = (Voldesc*)(dirp->iobuf);
  84                         haveplan9 = (strncmp((char*)v->z.boot.sysid, "PLAN 9", 6)==0);
  85                         if(haveplan9){
  86                                 if(noplan9) {
  87                                         chat("ignoring plan9");
  88                                         haveplan9 = 0;
  89                                 } else {
  90                                         fmt = '9';
  91                                         chat("plan9 iso...");
  92                                 }
  93                         }
  94                         continue;
  95                 }
  96
  97                 if(memcmp(&v->byte[8], "\01CDROM\01", 7) == 0){ /* high sierra */
  98                         if(dirp)
  99                                 putbuf(dirp);
 100                         dirp = p;
 101                         fmt = 'r';
 102                         dp = (Drec*)v->r.desc.rootdir;
 103                         blksize = l16(v->r.desc.blksize);
 104                         chat("high sierra, blksize=%d...", blksize);
 105                         continue;
 106                 }
 107
 108                 if(haveplan9==0 && !nojoliet
 109                 && memcmp(v->byte, "\02CD001\01", 7) == 0){
 110 chat("%d %d\n", haveplan9, nojoliet);
 111                         /*
 112                          * The right thing to do is walk the escape sequences looking
 113                          * for one of 25 2F 4[035], but Microsoft seems to not honor
 114                          * the format, which makes it hard to walk over.
 115                          */
 116                         q = v->z.desc.escapes;
 117                         if(q[0] == 0x25 && q[1] == 0x2F && (q[2] == 0x40 || q[2] == 0x43 || q[2] == 0x45)){     /* Joliet, it appears */
 118                                 if(dirp)
 119                                         putbuf(dirp);
 120                                 dirp = p;
 121                                 fmt = 'J';
 122                                 dp = (Drec*)v->z.desc.rootdir;
 123                                 if(blksize != l16(v->z.desc.blksize))
 124                                         fprint(2, "warning: suspicious Joliet blocksize\n");
 125                                 chat("joliet...");
 126                                 continue;
 127                         }
 128                 }
 129                 putbuf(p);
 130                 if(v->byte[0] == 0xFF)
 131                         break;
 132         }
 133
 134         if(fmt == 0){
 135                 if(dirp)
 136                         putbuf(dirp);
 137                 return -1;
 138         }
 139         assert(dirp != nil);
 140
 141         if(chatty)
 142                 showdrec(2, fmt, dp);
 143         if(blksize > Sectorsize){
 144                 chat("blksize too big...");
 145                 putbuf(dirp);
 146                 return -1;
 147         }
 148         if(waserror()){
 149                 putbuf(dirp);
 150                 nexterror();
 151         }
 152         root->len = sizeof(Isofile) - sizeof(Drec) + dp->reclen;
 153         root->ptr = fp = ealloc(root->len);
 154
 155         if(haveplan9)
 156                 root->xf->isplan9 = 1;
 157
 158         fp->fmt = fmt;
 159         fp->blksize = blksize;
 160         fp->offset = 0;
 161         fp->doffset = 0;
 162         memmove(&fp->d, dp, dp->reclen);
 163         root->qid.path = l32(dp->addr);
 164         root->qid.type = QTDIR;
 165         putbuf(dirp);
 166         poperror();
 167         if(getdrec(root, rd) >= 0){
 168                 n = rd->reclen-(34+rd->namelen);
 169                 s = (uchar*)rd->name + rd->namelen;
 170                 if((uintptr)s & 1){
 171                         s++;
 172                         n--;
 173                 }
 174                 if(n >= 7 && s[0] == 'S' && s[1] == 'P' && s[2] == 7 &&
 175                    s[3] == 1 && s[4] == 0xBE && s[5] == 0xEF){
 176                         root->xf->issusp = 1;
 177                         root->xf->suspoff = s[6];
 178                         n -= root->xf->suspoff;
 179                         s += root->xf->suspoff;
 180                         for(; n >= 4; s += l, n -= l){
 181                                 l = s[2];
 182                                 if(s[0] == 'E' && s[1] == 'R'){
 183                                         if(!norock && s[4] == 10 && memcmp(s+8, "RRIP_1991A", 10) == 0)
 184                                                 root->xf->isrock = 1;
 185                                         break;
 186                                 } else if(s[0] == 'C' && s[1] == 'E' && s[2] >= 28){
 187                                         n = getcontin(root->xf->d, s, &s);
 188                                         continue;
 189                                 } else if(s[0] == 'R' && s[1] == 'R'){
 190                                         if(!norock)
 191                                                 root->xf->isrock = 1;
 192                                         break;
 193                                 } else if(s[0] == 'S' && s[1] == 'T')
 194                                         break;
 195                         }
 196                 }
 197         }
 198         if(root->xf->isrock)
 199                 chat("Rock Ridge...");
 200         fp->offset = 0;
 201         fp->doffset = 0;
 202         return 0;
 203 }
 204
 205 static void
 206 iclone(Xfile *of, Xfile *nf)
 207 {
 208         USED(of, nf);
 209 }
 210
 211 static void
 212 iwalkup(Xfile *f)
 213 {
 214         long paddr;
 215         uchar dbuf[256];
 216         Drec *d = (Drec *)dbuf;
 217         Xfile pf, ppf;
 218         Isofile piso, ppiso;
 219
 220         memset(&pf, 0, sizeof pf);
 221         memset(&ppf, 0, sizeof ppf);
 222         pf.ptr = &piso;
 223         ppf.ptr = &ppiso;
 224         if(opendotdot(f, &pf) < 0)
 225                 error("can't open pf");
 226         paddr = l32(pf.ptr->d.addr);
 227         if(l32(f->ptr->d.addr) == paddr)
 228                 return;
 229         if(opendotdot(&pf, &ppf) < 0)
 230                 error("can't open ppf");
 231         while(getdrec(&ppf, d) >= 0){
 232                 if(l32(d->addr) == paddr){
 233                         newdrec(f, d);
 234                         f->qid.path = paddr;
 235                         f->qid.type = QTDIR;
 236                         return;
 237                 }
 238         }
 239         error("can't find addr of ..");
 240 }
 241
 242 static int
 243 casestrcmp(int isplan9, char *a, char *b)
 244 {
 245         if(isplan9)
 246                 return strcmp(a, b);
 247         return cistrcmp(a, b);
 248 }
 249
 250 static void
 251 iwalk(Xfile *f, char *name)
 252 {
 253         Isofile *ip = f->ptr;
 254         uchar dbuf[256];
 255         char nbuf[4*Maxname];
 256         Drec *d = (Drec*)dbuf;
 257         Dir dir;
 258         char *p;
 259         int len, vers, dvers;
 260
 261         vers = -1;
 262         if(p = strchr(name, ';')) {     /* assign = */
 263                 len = p-name;
 264                 if(len >= Maxname)
 265                         len = Maxname-1;
 266                 memmove(nbuf, name, len);
 267                 vers = strtoul(p+1, 0, 10);
 268                 name = nbuf;
 269         }
 270 /*
 271         len = strlen(name);
 272         if(len >= Maxname){
 273                 len = Maxname-1;
 274                 if(name != nbuf){
 275                         memmove(nbuf, name, len);
 276                         name = nbuf;
 277                 }
 278                 name[len] = 0;
 279         }
 280 */
 281
 282         chat("%d \"%s\"...", strlen(name), name);
 283         ip->offset = 0;
 284         setnames(&dir, nbuf);
 285         while(getdrec(f, d) >= 0) {
 286                 dvers = rzdir(f->xf, &dir, ip->fmt, d);
 287                 if(casestrcmp(f->xf->isplan9||f->xf->isrock, name, dir.name) != 0)
 288                         continue;
 289                 newdrec(f, d);
 290                 f->qid.path = dir.qid.path;
 291                 f->qid.type = dir.qid.type;
 292                 USED(dvers);
 293                 return;
 294         }
 295         USED(vers);
 296         error(Enonexist);
 297 }
 298
 299 static void
 300 iopen(Xfile *f, int mode)
 301 {
 302         mode &= ~OCEXEC;
 303         if(mode != OREAD && mode != OEXEC)
 304                 error(Eperm);
 305         f->ptr->offset = 0;
 306         f->ptr->doffset = 0;
 307 }
 308
 309 static void
 310 icreate(Xfile *f, char *name, long perm, int mode)
 311 {
 312         USED(f, name, perm, mode);
 313         error(Eperm);
 314 }
 315
 316 static long
 317 ireaddir(Xfile *f, uchar *buf, vlong offset, long count)
 318 {
 319         Isofile *ip = f->ptr;
 320         Dir d;
 321         char names[4*Maxname];
 322         uchar dbuf[256];
 323         Drec *drec = (Drec *)dbuf;
 324         int n, rcnt;
 325
 326         if(offset==0){
 327                 ip->offset = 0;
 328                 ip->doffset = 0;
 329         }else if(offset != ip->doffset)
 330                 error("seek in directory not allowed");
 331
 332         rcnt = 0;
 333         setnames(&d, names);
 334         while(rcnt < count && getdrec(f, drec) >= 0){
 335                 if(drec->namelen == 1){
 336                         if(drec->name[0] == 0)
 337                                 continue;
 338                         if(drec->name[0] == 1)
 339                                 continue;
 340                 }
 341                 rzdir(f->xf, &d, ip->fmt, drec);
 342                 d.qid.vers = f->qid.vers;
 343                 if((n = convD2M(&d, buf+rcnt, count-rcnt)) <= BIT16SZ){
 344                         ungetdrec(f);
 345                         break;
 346                 }
 347                 rcnt += n;
 348         }
 349         ip->doffset += rcnt;
 350         return rcnt;
 351 }
 352
 353 static long
 354 iread(Xfile *f, char *buf, vlong offset, long count)
 355 {
 356         int n, o, rcnt = 0;
 357         vlong size, addr;
 358         Isofile *ip = f->ptr;
 359         Iobuf *p;
 360
 361         size = fakemax(l32(ip->d.size));
 362         if(offset >= size)
 363                 return 0;
 364         if(offset+count > size)
 365                 count = size - offset;
 366         addr = ((vlong)l32(ip->d.addr) + ip->d.attrlen)*ip->blksize + offset;
 367         o = addr % Sectorsize;
 368         addr /= Sectorsize;
 369         /*chat("d.addr=%ld, addr=%lld, o=%d...", l32(ip->d.addr), addr, o);*/
 370         n = Sectorsize - o;
 371
 372         while(count > 0){
 373                 if(n > count)
 374                         n = count;
 375                 p = getbuf(f->xf->d, addr, 0);
 376                 memmove(&buf[rcnt], &p->iobuf[o], n);
 377                 putbuf(p);
 378                 count -= n;
 379                 rcnt += n;
 380                 ++addr;
 381                 o = 0;
 382                 n = Sectorsize;
 383         }
 384         return rcnt;
 385 }
 386
 387 static long
 388 iwrite(Xfile *f, char *buf, vlong offset, long count)
 389 {
 390         USED(f, buf, offset, count);
 391         error(Eperm);
 392         return 0;
 393 }
 394
 395 static void
 396 iclunk(Xfile *f)
 397 {
 398         USED(f);
 399 }
 400
 401 static void
 402 iremove(Xfile *f)
 403 {
 404         USED(f);
 405         error(Eperm);
 406 }
 407
 408 static void
 409 istat(Xfile *f, Dir *d)
 410 {
 411         Isofile *ip = f->ptr;
 412
 413         rzdir(f->xf, d, ip->fmt, &ip->d);
 414         d->qid.vers = f->qid.vers;
 415         if(d->qid.path==f->xf->rootqid.path){
 416                 d->qid.path = 0;
 417                 d->qid.type = QTDIR;
 418         }
 419 }
 420
 421 static void
 422 iwstat(Xfile *f, Dir *d)
 423 {
 424         USED(f, d);
 425         error(Eperm);
 426 }
 427
 428 static int
 429 showdrec(int fd, int fmt, void *x)
 430 {
 431         Drec *d = (Drec *)x;
 432         int namelen;
 433         int syslen;
 434
 435         if(d->reclen == 0)
 436                 return 0;
 437         fprint(fd, "%d %d %ld %ld ",
 438                 d->reclen, d->attrlen, l32(d->addr), l32(d->size));
 439         fprint(fd, "%s 0x%2.2x %d %d %ld ",
 440                 rdate(d->date, fmt), (fmt=='z' ? d->flags : d->r_flags),
 441                 d->unitsize, d->gapsize, l16(d->vseqno));
 442         fprint(fd, "%d %s", d->namelen, nstr(d->name, d->namelen));
 443         if(fmt != 'J'){
 444                 namelen = d->namelen + (1-(d->namelen&1));
 445                 syslen = d->reclen - 33 - namelen;
 446                 if(syslen != 0)
 447                         fprint(fd, " %s", nstr(&d->name[namelen], syslen));
 448         }
 449         fprint(fd, "\n");
 450         return d->reclen + (d->reclen&1);
 451 }
 452
 453 static void
 454 newdrec(Xfile *f, Drec *dp)
 455 {
 456         Isofile *x = f->ptr;
 457         Isofile *n;
 458         int len;
 459
 460         len = sizeof(Isofile) - sizeof(Drec) + dp->reclen;
 461         n = ealloc(len);
 462         n->fmt = x->fmt;
 463         n->blksize = x->blksize;
 464         n->offset = 0;
 465         n->doffset = 0;
 466         memmove(&n->d, dp, dp->reclen);
 467         free(x);
 468         f->ptr = n;
 469         f->len = len;
 470 }
 471
 472 static void
 473 ungetdrec(Xfile *f)
 474 {
 475         Isofile *ip = f->ptr;
 476
 477         if(ip->offset >= ip->odelta){
 478                 ip->offset -= ip->odelta;
 479                 ip->odelta = 0;
 480         }
 481 }
 482
 483 static int
 484 getdrec(Xfile *f, void *buf)
 485 {
 486         Isofile *ip = f->ptr;
 487         int len = 0, boff = 0;
 488         vlong addr;
 489         uvlong size;
 490         Iobuf *p = 0;
 491
 492         if(!ip)
 493                 return -1;
 494         size = fakemax(l32(ip->d.size));
 495         while(ip->offset < size){
 496                 addr = (l32(ip->d.addr)+ip->d.attrlen)*ip->blksize + ip->offset;
 497                 boff = addr % Sectorsize;
 498                 if(boff > Sectorsize-34){
 499                         ip->offset += Sectorsize-boff;
 500                         continue;
 501                 }
 502                 p = getbuf(f->xf->d, addr/Sectorsize, 1);
 503                 len = p->iobuf[boff];
 504                 if(len >= 34)
 505                         break;
 506                 putbuf(p);
 507                 p = 0;
 508                 ip->offset += Sectorsize-boff;
 509         }
 510         if(p) {
 511                 memmove(buf, &p->iobuf[boff], len);
 512                 putbuf(p);
 513                 ip->odelta = len + (len&1);
 514                 ip->offset += ip->odelta;
 515                 return 0;
 516         }
 517         return -1;
 518 }
 519
 520 static int
 521 opendotdot(Xfile *f, Xfile *pf)
 522 {
 523         uchar dbuf[256];
 524         Drec *d = (Drec *)dbuf;
 525         Isofile *ip = f->ptr, *pip = pf->ptr;
 526
 527         ip->offset = 0;
 528         if(getdrec(f, d) < 0){
 529                 chat("opendotdot: getdrec(.) failed...");
 530                 return -1;
 531         }
 532         if(d->namelen != 1 || d->name[0] != 0){
 533                 chat("opendotdot: no . entry...");
 534                 return -1;
 535         }
 536         if(l32(d->addr) != l32(ip->d.addr)){
 537                 chat("opendotdot: bad . address...");
 538                 return -1;
 539         }
 540         if(getdrec(f, d) < 0){
 541                 chat("opendotdot: getdrec(..) failed...");
 542                 return -1;
 543         }
 544         if(d->namelen != 1 || d->name[0] != 1){
 545                 chat("opendotdot: no .. entry...");
 546                 return -1;
 547         }
 548
 549         pf->xf = f->xf;
 550         pip->fmt = ip->fmt;
 551         pip->blksize = ip->blksize;
 552         pip->offset = 0;
 553         pip->doffset = 0;
 554         pip->d = *d;
 555         return 0;
 556 }
 557
 558 enum {
 559         Hname = 1,
 560         Hmode = 2,
 561 };
 562
 563 static int
 564 rzdir(Xfs *fs, Dir *d, int fmt, Drec *dp)
 565 {
 566         int n, flags, i, j, lj, nl, vers, sysl, mode, l, have;
 567         uchar *s;
 568         char *p;
 569         char buf[Maxname+UTFmax+1];
 570         uchar *q;
 571         Rune r;
 572
 573         have = 0;
 574         flags = 0;
 575         vers = -1;
 576         d->qid.path = l32(dp->addr);
 577         d->qid.type = 0;
 578         d->qid.vers = 0;
 579         n = dp->namelen;
 580         memset(d->name, 0, Maxname);
 581         if(n == 1) {
 582                 switch(dp->name[0]){
 583                 case 1:
 584                         d->name[1] = '.';
 585                         /* fall through */
 586                 case 0:
 587                         d->name[0] = '.';
 588                         have = Hname;
 589                         break;
 590                 default:
 591                         d->name[0] = tolower(dp->name[0]);
 592                 }
 593         } else {
 594                 if(fmt == 'J'){ /* Joliet, 16-bit Unicode */
 595                         q = (uchar*)dp->name;
 596                         for(i=j=lj=0; i<n && j<Maxname; i+=2){
 597                                 lj = j;
 598                                 r = (q[i]<<8)|q[i+1];
 599                                 j += runetochar(buf+j, &r);
 600                         }
 601                         if(j >= Maxname)
 602                                 j = lj;
 603                         memmove(d->name, buf, j);
 604                 }else{
 605                         if(n >= Maxname)
 606                                 n = Maxname-1;
 607                         for(i=0; i<n; i++)
 608                                 d->name[i] = tolower(dp->name[i]);
 609                 }
 610         }
 611
 612         sysl = dp->reclen-(34+dp->namelen);
 613         s = (uchar*)dp->name + dp->namelen;
 614         if(((uintptr)s) & 1) {
 615                 s++;
 616                 sysl--;
 617         }
 618         if(fs->isplan9 && sysl > 0) {
 619                 /*
 620                  * get gid, uid, mode and possibly name
 621                  * from plan9 directory extension
 622                  */
 623                 nl = *s;
 624                 if(nl >= Maxname)
 625                         nl = Maxname-1;
 626                 if(nl) {
 627                         memset(d->name, 0, Maxname);
 628                         memmove(d->name, s+1, nl);
 629                 }
 630                 s += 1 + *s;
 631                 nl = *s;
 632                 if(nl >= Maxname)
 633                         nl = Maxname-1;
 634                 memset(d->uid, 0, Maxname);
 635                 memmove(d->uid, s+1, nl);
 636                 s += 1 + *s;
 637                 nl = *s;
 638                 if(nl >= Maxname)
 639                         nl = Maxname-1;
 640                 memset(d->gid, 0, Maxname);
 641                 memmove(d->gid, s+1, nl);
 642                 s += 1 + *s;
 643                 if(((uintptr)s) & 1)
 644                         s++;
 645                 d->mode = l32(s);
 646                 if(d->mode & DMDIR)
 647                         d->qid.type |= QTDIR;
 648         } else {
 649                 d->mode = 0444;
 650                 switch(fmt) {
 651                 case 'z':
 652                         if(fs->isrock)
 653                                 strcpy(d->gid, "ridge");
 654                         else
 655                                 strcpy(d->gid, "iso9660");
 656                         flags = dp->flags;
 657                         break;
 658                 case 'r':
 659                         strcpy(d->gid, "sierra");
 660                         flags = dp->r_flags;
 661                         break;
 662                 case 'J':
 663                         strcpy(d->gid, "joliet");
 664                         flags = dp->flags;
 665                         break;
 666                 case '9':
 667                         strcpy(d->gid, "plan9");
 668                         flags = dp->flags;
 669                         break;
 670                 }
 671                 if(flags & 0x02){
 672                         d->qid.type |= QTDIR;
 673                         d->mode |= DMDIR|0111;
 674                 }
 675                 strcpy(d->uid, "cdrom");
 676                 if(fmt!='9' && !(d->mode&DMDIR)){
 677                         /*
 678                          * ISO 9660 actually requires that you always have a . and a ;,
 679                          * even if there is no version and no extension.  Very few writers
 680                          * do this.  If the version is present, we use it for qid.vers.
 681                          * If there is no extension but there is a dot, we strip it off.
 682                          * (VMS heads couldn't comprehend the dot as a file name character
 683                          * rather than as just a separator between name and extension.)
 684                          *
 685                          * We don't do this for directory names because directories are
 686                          * not allowed to have extensions and versions.
 687                          */
 688                         if((p=strchr(d->name, ';')) != nil){
 689                                 vers = strtoul(p+1, 0, 0);
 690                                 d->qid.vers = vers;
 691                                 *p = '\0';
 692                         }
 693                         if((p=strchr(d->name, '.')) != nil && *(p+1)=='\0')
 694                                 *p = '\0';
 695                 }
 696                 if(fs->issusp){
 697                         nl = 0;
 698                         s += fs->suspoff;
 699                         sysl -= fs->suspoff;
 700                         for(; sysl >= 4 && have != (Hname|Hmode); sysl -= l, s += l){
 701                                 if(s[0] == 0 && ((uintptr)s & 1)){
 702                                         /* MacOS pads individual entries, contrary to spec */
 703                                         s++;
 704                                         sysl--;
 705                                 }
 706                                 l = s[2];
 707                                 if(s[0] == 'P' && s[1] == 'X' && s[3] == 1){
 708                                         /* posix file attributes */
 709                                         mode = l32(s+4);
 710                                         d->mode = mode & 0777;
 711                                         if((mode & 0170000) == 040000){
 712                                                 d->mode |= DMDIR;
 713                                                 d->qid.type |= QTDIR;
 714                                         }
 715                                         have |= Hmode;
 716                                 } else if(s[0] == 'N' && s[1] == 'M' && s[3] == 1){
 717                                         /* alternative name */
 718                                         if((s[4] & ~1) == 0){
 719                                                 i = nl+l-5;
 720                                                 if(i >= Maxname)
 721                                                         i = Maxname-1;
 722                                                 if((i -= nl) > 0){
 723                                                         memmove(d->name+nl, s+5, i);
 724                                                         nl += i;
 725                                                 }
 726                                                 if(s[4] == 0)
 727                                                         have |= Hname;
 728                                         }
 729                                 } else if(s[0] == 'C' && s[1] == 'E' && s[2] >= 28){
 730                                         sysl = getcontin(fs->d, s, &s);
 731                                         continue;
 732                                 } else if(s[0] == 'S' && s[1] == 'T')
 733                                         break;
 734                         }
 735                 }
 736         }
 737         d->length = 0;
 738         if((d->mode & DMDIR) == 0)
 739                 d->length = fakemax(l32(dp->size));
 740         d->type = 0;
 741         d->dev = 0;
 742         d->atime = gtime(dp->date);
 743         d->mtime = d->atime;
 744         return vers;
 745 }
 746
 747 static int
 748 getcontin(Xdata *dev, uchar *p, uchar **s)
 749 {
 750         long bn, off, len;
 751         Iobuf *b;
 752
 753         bn = l32(p+4);
 754         off = l32(p+12);
 755         len = l32(p+20);
 756         chat("getcontin %d...", bn);
 757         b = getbuf(dev, bn, 1);
 758         if(b == 0){
 759                 *s = 0;
 760                 return 0;
 761         }
 762         *s = b->iobuf+off;
 763         putbuf(b);
 764         return len;
 765 }
 766
 767 static char *
 768 nstr(uchar *p, int n)
 769 {
 770         static char buf[132];
 771         char *q = buf;
 772
 773         while(--n >= 0){
 774                 if(*p == '\\')
 775                         *q++ = '\\';
 776                 if(' ' <= *p && *p <= '~')
 777                         *q++ = *p++;
 778                 else
 779                         q += sprint(q, "\\%2.2ux", *p++);
 780         }
 781         *q = 0;
 782         return buf;
 783 }
 784
 785 static char *
 786 rdate(uchar *p, int fmt)
 787 {
 788         static char buf[64];
 789         int htz, s, n;
 790
 791         n = sprint(buf, "%2.2d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d",
 792                 p[0], p[1], p[2], p[3], p[4], p[5]);
 793         if(fmt == 'z'){
 794                 htz = p[6];
 795                 if(htz >= 128){
 796                         htz = 256-htz;
 797                         s = '-';
 798                 }else
 799                         s = '+';
 800                 sprint(&buf[n], " (%c%.1f)", s, (float)htz/2);
 801         }
 802         return buf;
 803 }
 804
 805 static char
 806 dmsize[12] =
 807 {
 808         31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
 809 };
 810
 811 static int
 812 dysize(int y)
 813 {
 814
 815         if((y%4) == 0)
 816                 return 366;
 817         return 365;
 818 }
 819
 820 static long
 821 gtime(uchar *p) /* yMdhmsz */
 822 {
 823         long t;
 824         int i, y, M, d, h, m, s, tz;
 825
 826         y=p[0]; M=p[1]; d=p[2];
 827         h=p[3]; m=p[4]; s=p[5]; tz=p[6];
 828         USED(tz);
 829         y += 1900;
 830         if (y < 1970)
 831                 return 0;
 832         if (M < 1 || M > 12)
 833                 return 0;
 834         if (d < 1 || d > dmsize[M-1])
 835                 if (!(M == 2 && d == 29 && dysize(y) == 366))
 836                         return 0;
 837         if (h > 23)
 838                 return 0;
 839         if (m > 59)
 840                 return 0;
 841         if (s > 59)
 842                 return 0;
 843         t = 0;
 844         for(i=1970; i<y; i++)
 845                 t += dysize(i);
 846         if (dysize(y)==366 && M >= 3)
 847                 t++;
 848         while(--M)
 849                 t += dmsize[M-1];
 850         t += d-1;
 851         t = 24*t + h;
 852         t = 60*t + m;
 853         t = 60*t + s;
 854         return t;
 855 }
 856
 857 #define p       ((uchar*)arg)
 858
 859 static long
 860 l16(void *arg)
 861 {
 862         long v;
 863
 864         v = ((long)p[1]<<8)|p[0];
 865         if (v >= 0x8000L)
 866                 v -= 0x10000L;
 867         return v;
 868 }
 869
 870 static long
 871 l32(void *arg)
 872 {
 873         return ((((((long)p[3]<<8)|p[2])<<8)|p[1])<<8)|p[0];
 874 }
 875
 876 #undef  p