sys/src/cmd/dossrv/dossubs.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <bio.h>
   4 #include <auth.h>
   5 #include <fcall.h>
   6 #include "iotrack.h"
   7 #include "dat.h"
   8 #include "fns.h"
   9
  10 static uchar    isdos[256];
  11
  12 int
  13 isdosfs(uchar *buf)
  14 {
  15         /*
  16          * When dynamic disc managers move the disc partition,
  17          * they make it start with 0xE9.
  18          */
  19         if(buf[0] == 0xE9)
  20                 return 1;
  21
  22         /*
  23          * Check if the jump displacement (magic[1]) is too short for a FAT.
  24          *
  25          * check now omitted due to digital cameras that use a 0 jump.
  26          * the ecma-107 standard says this is okay and that interoperable fat
  27          * implementations shouldn't assume this:
  28          * http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-107.pdf,
  29          * page 11.
  30          */
  31         if(buf[0] == 0xEB && buf[2] == 0x90 /* && buf[1] >= 0x30 */)
  32                 return 1;
  33         if(chatty)
  34                 fprint(2, "bad sig %.2ux %.2ux %.2uxn", buf[0], buf[1], buf[2]);
  35
  36         return 0;
  37 }
  38
  39 int
  40 dosfs(Xfs *xf)
  41 {
  42         Iosect *p, *p1;
  43         Dosboot *b;
  44         Fatinfo *fi;
  45         Dosboot32 *b32;
  46         Dosbpb *bp;
  47         long fisec, extflags;
  48         int i;
  49
  50         if(!isdos['a']){
  51                 for(i = 'a'; i <= 'z'; i++)
  52                         isdos[i] = 1;
  53                 for(i = 'A'; i <= 'Z'; i++)
  54                         isdos[i] = 1;
  55                 for(i = '0'; i <= '9'; i++)
  56                         isdos[i] = 1;
  57                 isdos['$'] = 1;
  58                 isdos['%'] = 1;
  59                 isdos['''] = 1;
  60                 isdos['-'] = 1;
  61                 isdos['_'] = 1;
  62                 isdos['@'] = 1;
  63                 isdos['~'] = 1;
  64                 isdos['`'] = 1;
  65                 isdos['!'] = 1;
  66                 isdos['('] = 1;
  67                 isdos[')'] = 1;
  68                 isdos['{'] = 1;
  69                 isdos['}'] = 1;
  70                 isdos['^'] = 1;
  71                 isdos['#'] = 1;
  72                 isdos['&'] = 1;
  73         }
  74
  75         p = getsect(xf, 0);
  76         if(p == 0)
  77                 return -1;
  78
  79         b = (Dosboot*)p->iobuf;
  80         if(b->clustsize == 0 || isdosfs(p->iobuf) == 0){
  81                 putsect(p);
  82                 return -1;
  83         }
  84
  85         bp = malloc(sizeof(Dosbpb));
  86         memset(bp, 0, sizeof(Dosbpb));  /* clear lock */
  87         xf->ptr = bp;
  88         xf->fmt = 1;
  89
  90         bp->sectsize = GSHORT(b->sectsize);
  91         bp->clustsize = b->clustsize;
  92         bp->nresrv = GSHORT(b->nresrv);
  93         bp->nfats = b->nfats;
  94         bp->rootsize = GSHORT(b->rootsize);
  95         bp->volsize = GSHORT(b->volsize);
  96         if(bp->volsize == 0)
  97                 bp->volsize = GLONG(b->bigvolsize);
  98         bp->mediadesc = b->mediadesc;
  99         bp->fatsize = GSHORT(b->fatsize);
 100         bp->fataddr = GSHORT(b->nresrv);
 101
 102         bp->fatinfo = 0;
 103
 104         if(bp->fatsize == 0){   /* is FAT32 */
 105                 if(chatty)
 106                         bootsecdump32(2, xf, (Dosboot32*)b);
 107                 xf->isfat32 = 1;
 108                 b32 = (Dosboot32*)b;
 109                 bp->fatsize = GLONG(b32->fatsize32);
 110                 if(bp->fatsize == 0){
 111                         putsect(p);
 112                         if(chatty)
 113                                 fprint(2, "fatsize 0\n");
 114                         return -1;
 115                 }
 116                 bp->dataaddr = bp->fataddr + bp->nfats*bp->fatsize;
 117                 bp->rootaddr = 0;
 118                 bp->rootstart = GLONG(b32->rootstart);
 119
 120                 /*
 121                  * disable fat mirroring?
 122                  */
 123                 extflags = GSHORT(b32->extflags);
 124                 if(extflags & 0x0080){
 125                         for(i = 0; i < 4; i++){
 126                                 if(extflags & (1 << i)){
 127                                         bp->fataddr += i * bp->fatsize;
 128                                         bp->nfats = 1;
 129                                         break;
 130                                 }
 131                         }
 132                 }
 133
 134                 /*
 135                  * fat free list info
 136                  */
 137                 bp->freeptr = FATRESRV;
 138                 fisec = GSHORT(b32->infospec);
 139                 if(fisec != 0 && fisec < GSHORT(b32->nresrv)){
 140                         p1 = getsect(xf, fisec);
 141                         if(p1 != nil){
 142                                 fi = (Fatinfo*)p1->iobuf;
 143                                 if(GLONG(fi->sig1) == FATINFOSIG1 && GLONG(fi->sig) == FATINFOSIG){
 144                                         bp->fatinfo = fisec;
 145                                         bp->freeptr = GLONG(fi->nextfree);
 146                                         bp->freeclusters = GLONG(fi->freeclust);
 147                                         chat("fat info: %ld free clusters, next free %ld\n", bp->freeclusters, bp->freeptr);
 148                                 }
 149                                 putsect(p1);
 150                         }
 151                 }
 152         }else{
 153                 if(chatty)
 154                         bootdump(2, b);
 155                 bp->rootaddr = bp->fataddr + bp->nfats*bp->fatsize;
 156                 bp->rootstart = 0;
 157                 i = bp->rootsize*DOSDIRSIZE + bp->sectsize-1;
 158                 i /= bp->sectsize;
 159                 bp->dataaddr = bp->rootaddr + i;
 160                 bp->freeptr = FATRESRV;
 161         }
 162         bp->fatclusters = FATRESRV+(bp->volsize - bp->dataaddr)/bp->clustsize;
 163
 164         if(xf->isfat32)
 165                 bp->fatbits = 32;
 166         else if(bp->fatclusters < 4087)
 167                 bp->fatbits = 12;
 168         else
 169                 bp->fatbits = 16;
 170
 171         chat("fatbits=%d (%d clusters)...", bp->fatbits, bp->fatclusters);
 172         for(i=0; i<b->nfats; i++)
 173                 chat("fat %d: %ld...", i, bp->fataddr+i*bp->fatsize);
 174         chat("root: %ld...", bp->rootaddr);
 175         chat("data: %ld...", bp->dataaddr);
 176         putsect(p);
 177         return 0;
 178 }
 179
 180 /*
 181  * initialize f to the root directory
 182  * this file has no Dosdir entry,
 183  * so we special case it all over.
 184  */
 185 void
 186 rootfile(Xfile *f)
 187 {
 188         Dosptr *dp;
 189
 190         dp = f->ptr;
 191         memset(dp, 0, sizeof(Dosptr));
 192         dp->prevaddr = -1;
 193 }
 194
 195 int
 196 isroot(ulong addr)
 197 {
 198         return addr == 0;
 199 }
 200
 201 int
 202 getfile(Xfile *f)
 203 {
 204         Dosptr *dp;
 205         Iosect *p;
 206
 207         dp = f->ptr;
 208         if(dp->p)
 209                 panic("getfile");
 210         p = getsect(f->xf, dp->addr);
 211         if(p == nil)
 212                 return -1;
 213
 214         /*
 215          * we could also make up a Dosdir for the root
 216          */
 217         dp->d = nil;
 218         if(!isroot(dp->addr)){
 219                 if(f->qid.path != QIDPATH(dp)){
 220                         chat("qid mismatch f=%#llux d=%#lux...", f->qid.path, QIDPATH(dp));
 221                         putsect(p);
 222                         errno = Enonexist;
 223                         return -1;
 224                 }
 225                 dp->d = (Dosdir *)&p->iobuf[dp->offset];
 226         }
 227         dp->p = p;
 228         return 0;
 229 }
 230
 231 void
 232 putfile(Xfile *f)
 233 {
 234         Dosptr *dp;
 235
 236         dp = f->ptr;
 237         if(!dp->p)
 238                 panic("putfile");
 239         putsect(dp->p);
 240         dp->p = nil;
 241         dp->d = nil;
 242 }
 243
 244 long
 245 getstart(Xfs *xf, Dosdir *d)
 246 {
 247         long start;
 248
 249         start = GSHORT(d->start);
 250         if(xf->isfat32)
 251                 start |= GSHORT(d->hstart)<<16;
 252         return start;
 253 }
 254
 255 void
 256 putstart(Xfs *xf, Dosdir *d, long start)
 257 {
 258         PSHORT(d->start, start);
 259         if(xf->isfat32)
 260                 PSHORT(d->hstart, start>>16);
 261 }
 262
 263 /*
 264  * return the disk cluster for the iclust cluster in f
 265  */
 266 long
 267 fileclust(Xfile *f, long iclust, int cflag)
 268 {
 269         Dosbpb *bp;
 270         Dosptr *dp;
 271         Dosdir *d;
 272         long start, clust, nskip, next;
 273
 274         bp = f->xf->ptr;
 275         dp = f->ptr;
 276         d = dp->d;
 277         next = 0;
 278
 279         /*
 280          * asking for the cluster of the root directory
 281          * is not a well-formed question, since the root directory
 282          * does not begin on a cluster boundary.
 283          */
 284         if(!f->xf->isfat32 && isroot(dp->addr))
 285                 return -1;
 286
 287         if(f->xf->isfat32 && isroot(dp->addr)){
 288                 start = bp->rootstart;
 289         }else{
 290                 start = getstart(f->xf, d);
 291                 if(start == 0){
 292                         if(!cflag)
 293                                 return -1;
 294                         mlock(bp);
 295                         start = falloc(f->xf);
 296                         unmlock(bp);
 297                         if(start <= 0)
 298                                 return -1;
 299                         puttime(d, 0);
 300                         putstart(f->xf, d, start);
 301                         dp->p->flags |= BMOD;
 302                         dp->clust = 0;
 303                 }
 304         }
 305         if(dp->clust == 0 || iclust < dp->iclust){
 306                 clust = start;
 307                 nskip = iclust;
 308         }else{
 309                 clust = dp->clust;
 310                 nskip = iclust - dp->iclust;
 311         }
 312         if(chatty > 1 && nskip > 0)
 313                 chat("clust %#lx, skip %ld...", clust, nskip);
 314         if(clust <= 0)
 315                 return -1;
 316         if(nskip > 0){
 317                 mlock(bp);
 318                 while(--nskip >= 0){
 319                         next = getfat(f->xf, clust);
 320                         if(chatty > 1)
 321                                 chat("->%#lx", next);
 322                         if(next > 0){
 323                                 clust = next;
 324                                 continue;
 325                         }else if(!cflag)
 326                                 break;
 327                         if(d && (d->attr&DSYSTEM)){
 328                                 next = cfalloc(f);
 329                                 if(next < 0)
 330                                         break;
 331                                 /* cfalloc will call putfat for us, since clust may change */
 332                         } else {
 333                                 next = falloc(f->xf);
 334                                 if(next < 0)
 335                                         break;
 336                                 putfat(f->xf, clust, next);
 337                         }
 338                         clust = next;
 339                 }
 340                 unmlock(bp);
 341                 if(next <= 0)
 342                         return -1;
 343                 dp->clust = clust;
 344                 dp->iclust = iclust;
 345         }
 346         if(chatty > 1)
 347                 chat(" clust(%#lx)=%#lx...", iclust, clust);
 348         return clust;
 349 }
 350
 351 /*
 352  * return the disk sector for the isect disk sector in f
 353  */
 354 long
 355 fileaddr(Xfile *f, long isect, int cflag)
 356 {
 357         Dosbpb *bp;
 358         Dosptr *dp;
 359         long clust;
 360
 361         bp = f->xf->ptr;
 362         dp = f->ptr;
 363         if(!f->xf->isfat32 && isroot(dp->addr)){
 364                 if(isect*bp->sectsize >= bp->rootsize*DOSDIRSIZE)
 365                         return -1;
 366                 return bp->rootaddr + isect;
 367         }
 368         clust = fileclust(f, isect/bp->clustsize, cflag);
 369         if(clust < 0)
 370                 return -1;
 371
 372         return clust2sect(bp, clust) + isect%bp->clustsize;
 373 }
 374
 375 /*
 376  * translate names
 377  */
 378 void
 379 fixname(char *buf)
 380 {
 381         int c;
 382         char *p;
 383
 384         p = buf;
 385         while(c = *p){
 386                 if(c == ':' && trspaces)
 387                         *p = ' ';
 388                 p++;
 389         }
 390 }
 391
 392 /*
 393  * classify the file name as one of
 394  *      Invalid - contains a bad character
 395  *      Short - short valid 8.3 name, no lowercase letters
 396  *      ShortLower - short valid 8.3 name except for lowercase letters
 397  *      Long - long name
 398  */
 399 int
 400 classifyname(char *buf)
 401 {
 402         char *p, *dot;
 403         int c, isextended, is8dot3, islower, ndot;
 404
 405         p = buf;
 406         isextended = 0;
 407         islower = 0;
 408         dot = nil;
 409         ndot = 0;
 410         while(c = (uchar)*p){
 411                 if(c&0x80)      /* UTF8 */
 412                         isextended = 1;
 413                 else if(c == '.'){
 414                         dot = p;
 415                         ndot++;
 416                 }else if(strchr("+,:;=[] ", c))
 417                         isextended = 1;
 418                 else if(!isdos[c])
 419                         return Invalid;
 420                 if('a' <= c && c <= 'z')
 421                         islower = 1;
 422                 p++;
 423         }
 424
 425         is8dot3 = (ndot==0 && p-buf <= 8) || (ndot==1 && dot-buf <= 8 && p-(dot+1) <= 3);
 426
 427         if(!isextended && is8dot3){
 428                 if(islower)
 429                         return ShortLower;
 430                 return Short;
 431         }
 432         return Long;
 433 }
 434
 435 /*
 436  * make an alias for a valid long file name
 437  */
 438 void
 439 mkalias(char *name, char *sname, int id)
 440 {
 441         Rune r;
 442         char *s, *e, sid[10];
 443         int i, esuf, v;
 444
 445         e = strrchr(name, '.');
 446         if(e == nil)
 447                 e = strchr(name, '\0');
 448
 449         s = name;
 450         i = 0;
 451         while(s < e && i < 6){
 452                 if(isdos[(uchar)*s])
 453                         sname[i++] = *s++;
 454                 else
 455                         s += chartorune(&r, s);
 456         }
 457
 458         v = snprint(sid, 10, "%d", id);
 459         if(i + 1 + v > 8)
 460                 i = 8 - 1 - v;
 461         sname[i++] = '~';
 462         strcpy(&sname[i], sid);
 463         i += v;
 464
 465         sname[i++] = '.';
 466         esuf = i + 3;
 467         if(esuf > 12)
 468                 panic("bad mkalias");
 469         while(*e && i < esuf){
 470                 if(isdos[(uchar)*e])
 471                         sname[i++] = *e++;
 472                 else
 473                         e += chartorune(&r, e);
 474         }
 475         if(sname[i-1] == '.')
 476                 i--;
 477         sname[i] = '\0';
 478 }
 479
 480 /*
 481  * check for valid plan 9 names,
 482  * rewrite ' ' to ':'
 483  */
 484 char isfrog[256]={
 485         /*NUL*/ 1, 1, 1, 1, 1, 1, 1, 1,
 486         /*BKS*/ 1, 1, 1, 1, 1, 1, 1, 1,
 487         /*DLE*/ 1, 1, 1, 1, 1, 1, 1, 1,
 488         /*CAN*/ 1, 1, 1, 1, 1, 1, 1, 1,
 489 /*      [' ']   1,      let's try this -rsc */
 490         ['/']   1,
 491         [0x7f]  1,
 492 };
 493
 494 int
 495 nameok(char *elem)
 496 {
 497         while(*elem) {
 498                 if(*elem == ' ' && trspaces)
 499                         *elem = ':';
 500                 if(isfrog[*(uchar*)elem])
 501                         return 0;
 502                 elem++;
 503         }
 504         return 1;
 505 }
 506
 507 /*
 508  * look for a directory entry matching name
 509  * always searches for long names which match a short name
 510  */
 511 int
 512 searchdir(Xfile *f, char *name, Dosptr *dp, int cflag, int longtype)
 513 {
 514         Xfs *xf;
 515         Iosect *p;
 516         Dosbpb *bp;
 517         Dosdir *d;
 518         char buf[261], *bname;
 519         int isect, addr, o, addr1, addr2, prevaddr, prevaddr1, o1, islong, have, need, sum;
 520
 521         xf = f->xf;
 522         bp = xf->ptr;
 523         addr1 = -1;
 524         addr2 = -1;
 525         prevaddr1 = -1;
 526         o1 = 0;
 527         islong = 0;
 528         sum = -1;
 529
 530         need = 1;
 531         if(longtype!=Short && cflag)
 532                 need += (utflen(name) + DOSRUNE-1) / DOSRUNE;
 533
 534         memset(dp, 0, sizeof(Dosptr));
 535         dp->prevaddr = -1;
 536         dp->naddr = -1;
 537         dp->paddr = ((Dosptr *)f->ptr)->addr;
 538         dp->poffset = ((Dosptr *)f->ptr)->offset;
 539
 540         have = 0;
 541         addr = -1;
 542         bname = nil;
 543         for(isect=0;; isect++){
 544                 prevaddr = addr;
 545                 addr = fileaddr(f, isect, cflag);
 546                 if(addr < 0)
 547                         break;
 548                 p = getsect(xf, addr);
 549                 if(p == 0)
 550                         break;
 551                 for(o=0; o<bp->sectsize; o+=DOSDIRSIZE){
 552                         d = (Dosdir *)&p->iobuf[o];
 553                         if(d->name[0] == 0x00){
 554                                 chat("end dir(0)...");
 555                                 putsect(p);
 556                                 if(!cflag)
 557                                         return -1;
 558
 559                                 /*
 560                                  * addr1 & o1 are the start of the dirs
 561                                  * addr2 is the optional second cluster used if the long name
 562                                  * entry does not fit within the addr1 cluster
 563                                  *
 564                                  * have tells us the number of contiguous free dirs
 565                                  * starting at addr1.o1; need are necessary to hold the long name.
 566                                  */
 567                                 if(addr1 < 0){
 568                                         addr1 = addr;
 569                                         prevaddr1 = prevaddr;
 570                                         o1 = o;
 571                                 }
 572                                 if(addr2 < 0 && (bp->sectsize-o)/DOSDIRSIZE + have < need){
 573                                         addr2 = fileaddr(f, isect+1, cflag);
 574                                         if(addr2 < 0)
 575                                                 goto breakout;
 576                                 }else if(addr2 < 0)
 577                                         addr2 = addr;
 578                                 if(addr2 == addr1)
 579                                         addr2 = -1;
 580                                 dp->addr = addr1;
 581                                 dp->offset = o1;
 582                                 dp->prevaddr = prevaddr1;
 583                                 dp->naddr = addr2;
 584                                 return 0;
 585                         }
 586                         if(d->name[0] == DOSEMPTY){
 587                                 if(chatty)
 588                                         fprint(2, "empty dir\n");
 589
 590                                 have++;
 591                                 if(addr1 == -1){
 592                                         addr1 = addr;
 593                                         o1 = o;
 594                                         prevaddr1 = prevaddr;
 595                                 }
 596                                 if(addr2 == -1 && have >= need)
 597                                         addr2 = addr;
 598                                 continue;
 599                         }
 600                         have = 0;
 601                         if(addr2 == -1)
 602                                 addr1 = -1;
 603
 604                         dirdump(d);
 605                         if((d->attr & 0xf) == 0xf){
 606                                 bname = getnamesect(buf, bname, p->iobuf + o, &islong, &sum, 1);
 607                                 continue;
 608                         }
 609                         if(d->attr & DVLABEL){
 610                                 islong = 0;
 611                                 continue;
 612                         }
 613                         if(islong != 1 || sum != aliassum(d) || cistrcmp(bname, name) != 0){
 614                                 bname = buf;
 615                                 getname(buf, d);
 616                         }
 617                         islong = 0;
 618                         if(cistrcmp(bname, name) != 0)
 619                                 continue;
 620                         if(chatty)
 621                                 fprint(2, "found\n");
 622                         if(cflag){
 623                                 putsect(p);
 624                                 return -1;
 625                         }
 626                         dp->addr = addr;
 627                         dp->prevaddr = prevaddr;
 628                         dp->offset = o;
 629                         dp->p = p;
 630                         dp->d = d;
 631                         return 0;
 632                 }
 633                 putsect(p);
 634         }
 635 breakout:
 636         chat("end dir(1)...");
 637         return -1;
 638 }
 639
 640 int
 641 emptydir(Xfile *f)
 642 {
 643         Xfs *xf = f->xf;
 644         Dosbpb *bp = xf->ptr;
 645         int isect, addr, o;
 646         Iosect *p;
 647         Dosdir *d;
 648
 649         for(isect=0;; isect++){
 650                 addr = fileaddr(f, isect, 0);
 651                 if(addr < 0)
 652                         break;
 653                 p = getsect(xf, addr);
 654                 if(p == 0)
 655                         return -1;
 656                 for(o=0; o<bp->sectsize; o+=DOSDIRSIZE){
 657                         d = (Dosdir *)&p->iobuf[o];
 658                         if(d->name[0] == 0x00){
 659                                 putsect(p);
 660                                 return 0;
 661                         }
 662                         if(d->name[0] == DOSEMPTY)
 663                                 continue;
 664                         if(d->name[0] == '.')
 665                                 continue;
 666                         if(d->attr&DVLABEL)
 667                                 continue;
 668                         putsect(p);
 669                         return -1;
 670                 }
 671                 putsect(p);
 672         }
 673         return 0;
 674 }
 675
 676 long
 677 readdir(Xfile *f, void *vbuf, long offset, long count)
 678 {
 679         Xfs *xf;
 680         Dosbpb *bp;
 681         Dir dir;
 682         int isect, addr, o, islong, sum;
 683         Iosect *p;
 684         Dosdir *d;
 685         long rcnt, n;
 686         char *name, snamebuf[8+1+3+1], namebuf[DOSNAMELEN];
 687         uchar *buf;
 688
 689         buf = vbuf;
 690         rcnt = 0;
 691         xf = f->xf;
 692         bp = xf->ptr;
 693         if(count <= 0)
 694                 return 0;
 695         islong = 0;
 696         sum = -1;
 697         name = nil;
 698         for(isect=0;; isect++){
 699                 addr = fileaddr(f, isect, 0);
 700                 if(addr < 0)
 701                         break;
 702                 p = getsect(xf, addr);
 703                 if(p == 0)
 704                         return -1;
 705                 for(o=0; o<bp->sectsize; o+=DOSDIRSIZE){
 706                         d = (Dosdir *)&p->iobuf[o];
 707                         if(d->name[0] == 0x00){
 708                                 putsect(p);
 709                                 return rcnt;
 710                         }
 711                         if(d->name[0] == DOSEMPTY)
 712                                 continue;
 713                         dirdump(d);
 714                         if(d->name[0] == '.'){
 715                                 if(d->name[1] == ' ' || d->name[1] == 0)
 716                                         continue;
 717                                 if(d->name[1] == '.' &&
 718                                   (d->name[2] == ' ' || d->name[2] == 0))
 719                                         continue;
 720                         }
 721                         if((d->attr & 0xf) == 0xf){
 722                                 name = getnamesect(namebuf, name, p->iobuf+o, &islong, &sum, 1);
 723                                 continue;
 724                         }
 725                         if(d->attr & DVLABEL){
 726                                 islong = 0;
 727                                 continue;
 728                         }
 729                         dir.name = snamebuf;
 730                         getdir(xf, &dir, d, addr, o);
 731                         if(islong == 1 && nameok(name) && sum == aliassum(d))
 732                                 dir.name = name;
 733                         islong = 0;
 734                         n = convD2M(&dir, &buf[rcnt], count - rcnt);
 735                         name = nil;
 736                         if(n <= BIT16SZ){       /* no room for next entry */
 737                                 putsect(p);
 738                                 return rcnt;
 739                         }
 740                         rcnt += n;
 741                         if(offset > 0){
 742                                 offset -= rcnt;
 743                                 rcnt = 0;
 744                                 islong = 0;
 745                                 continue;
 746                         }
 747                         if(rcnt == count){
 748                                 putsect(p);
 749                                 return rcnt;
 750                         }
 751                 }
 752                 putsect(p);
 753         }
 754         return rcnt;
 755 }
 756
 757 /*
 758  * set up ndp for a directory's parent
 759  * the hardest part is setting up paddr
 760  */
 761 int
 762 walkup(Xfile *f, Dosptr *ndp)
 763 {
 764         Dosbpb *bp;
 765         Dosptr *dp;
 766         Dosdir *xd;
 767         Iosect *p;
 768         long k, o, so, start, pstart, ppstart, st, ppclust;
 769
 770         bp = f->xf->ptr;
 771         dp = f->ptr;
 772         memset(ndp, 0, sizeof(Dosptr));
 773         ndp->prevaddr = -1;
 774         ndp->naddr = -1;
 775         ndp->addr = dp->paddr;
 776         ndp->offset = dp->poffset;
 777
 778         chat("walkup: paddr=%#lx...", dp->paddr);
 779
 780         /*
 781          * root's paddr is always itself
 782          */
 783         if(isroot(dp->paddr))
 784                 return 0;
 785
 786         /*
 787          * find the start of our parent's directory
 788          */
 789         p = getsect(f->xf, dp->paddr);
 790         if(p == nil)
 791                 goto error;
 792         xd = (Dosdir *)&p->iobuf[dp->poffset];
 793         dirdump(xd);
 794         start = getstart(f->xf, xd);
 795         chat("start=%#lx...", start);
 796         if(start == 0)
 797                 goto error;
 798         putsect(p);
 799
 800         /*
 801          * verify that parent's . points to itself
 802          */
 803         p = getsect(f->xf, clust2sect(bp, start));
 804         if(p == nil)
 805                 goto error;
 806         xd = (Dosdir *)p->iobuf;
 807         dirdump(xd);
 808         st = getstart(f->xf, xd);
 809         if(xd->name[0]!='.' || xd->name[1]!=' ' || start!=st)
 810                 goto error;
 811
 812         /*
 813          * parent's .. is the next entry, and has start of parent's parent
 814          */
 815         xd++;
 816         dirdump(xd);
 817         if(xd->name[0] != '.' || xd->name[1] != '.')
 818                 goto error;
 819         pstart = getstart(f->xf, xd);
 820         putsect(p);
 821
 822         /*
 823          * we're done if parent is root
 824          */
 825         if(pstart == 0 || f->xf->isfat32 && pstart == bp->rootstart)
 826                 return 0;
 827
 828         /*
 829          * verify that parent's . points to itself
 830          */
 831         p = getsect(f->xf, clust2sect(bp, pstart));
 832         if(p == 0){
 833                 chat("getsect %ld failed\n", pstart);
 834                 goto error;
 835         }
 836         xd = (Dosdir *)p->iobuf;
 837         dirdump(xd);
 838         st = getstart(f->xf, xd);
 839         if(xd->name[0]!='.' || xd->name[1]!=' ' || pstart!=st)
 840                 goto error;
 841
 842         /*
 843          * parent's parent's .. is the next entry, and has start of parent's parent's parent
 844          */
 845         xd++;
 846         dirdump(xd);
 847         if(xd->name[0] != '.' || xd->name[1] != '.')
 848                 goto error;
 849         ppstart = getstart(f->xf, xd);
 850         putsect(p);
 851
 852         /*
 853          * open parent's parent's parent, and walk through it until parent's parent is found
 854          * need this to find parent's parent's addr and offset
 855          */
 856         ppclust = ppstart;
 857         if(f->xf->isfat32 && ppclust == 0){
 858                 ppclust = bp->rootstart;
 859                 chat("ppclust 0, resetting to rootstart\n");
 860         }
 861         k = ppclust ? clust2sect(bp, ppclust) : bp->rootaddr;
 862         p = getsect(f->xf, k);
 863         if(p == nil){
 864                 chat("getsect %ld failed\n", k);
 865                 goto error;
 866         }
 867         xd = (Dosdir *)p->iobuf;
 868         dirdump(xd);
 869         if(ppstart){
 870                 st = getstart(f->xf, xd);
 871                 if(xd->name[0]!='.' || xd->name[1]!=' ' || ppstart!=st)
 872                         goto error;
 873         }
 874         for(so=1;; so++){
 875                 for(o=0; o<bp->sectsize; o+=DOSDIRSIZE){
 876                         xd = (Dosdir *)&p->iobuf[o];
 877                         if(xd->name[0] == 0x00){
 878                                 chat("end dir\n");
 879                                 goto error;
 880                         }
 881                         if(xd->name[0] == DOSEMPTY)
 882                                 continue;
 883                         st = getstart(f->xf, xd);
 884                         if(st == pstart)
 885                                 goto out;
 886                 }
 887                 if(ppclust){
 888                         if(so%bp->clustsize == 0){
 889                                 mlock(bp);
 890                                 ppclust = getfat(f->xf, ppclust);
 891                                 unmlock(bp);
 892                                 if(ppclust < 0){
 893                                         chat("getfat %ld failed\n", ppclust);
 894                                         goto error;
 895                                 }
 896                         }
 897                         k = clust2sect(bp, ppclust) +
 898                                 so%bp->clustsize;
 899                 }else{
 900                         if(so*bp->sectsize >= bp->rootsize*DOSDIRSIZE)
 901                                 goto error;
 902                         k = bp->rootaddr + so;
 903                 }
 904                 putsect(p);
 905                 p = getsect(f->xf, k);
 906                 if(p == 0){
 907                         chat("getsect %ld failed\n", k);
 908                         goto error;
 909                 }
 910         }
 911 out:
 912         putsect(p);
 913         ndp->paddr = k;
 914         ndp->poffset = o;
 915         return 0;
 916
 917 error:
 918         if(p)
 919                 putsect(p);
 920         return -1;
 921 }
 922
 923 long
 924 readfile(Xfile *f, void *vbuf, long offset, long count)
 925 {
 926         Xfs *xf = f->xf;
 927         Dosbpb *bp = xf->ptr;
 928         Dosptr *dp = f->ptr;
 929         Dosdir *d = dp->d;
 930         int isect, addr, o, c;
 931         Iosect *p;
 932         uchar *buf;
 933         long length, rcnt;
 934
 935         rcnt = 0;
 936         length = GLONG(d->length);
 937         buf = vbuf;
 938         if(offset >= length)
 939                 return 0;
 940         if(offset+count >= length)
 941                 count = length - offset;
 942         isect = offset/bp->sectsize;
 943         o = offset%bp->sectsize;
 944         while(count > 0){
 945                 addr = fileaddr(f, isect++, 0);
 946                 if(addr < 0)
 947                         break;
 948                 c = bp->sectsize - o;
 949                 if(c > count)
 950                         c = count;
 951                 p = getsect(xf, addr);
 952                 if(p == 0)
 953                         return -1;
 954                 memmove(&buf[rcnt], &p->iobuf[o], c);
 955                 putsect(p);
 956                 count -= c;
 957                 rcnt += c;
 958                 o = 0;
 959         }
 960         return rcnt;
 961 }
 962
 963 long
 964 writefile(Xfile *f, void *vbuf, long offset, long count)
 965 {
 966         Xfs *xf = f->xf;
 967         Dosbpb *bp = xf->ptr;
 968         Dosptr *dp = f->ptr;
 969         Dosdir *d = dp->d;
 970         int isect, addr = 0, o, c;
 971         Iosect *p;
 972         uchar *buf;
 973         long length, rcnt = 0, dlen;
 974
 975         buf = vbuf;
 976         isect = offset/bp->sectsize;
 977         o = offset%bp->sectsize;
 978         while(count > 0){
 979                 addr = fileaddr(f, isect++, 1);
 980                 if(addr < 0)
 981                         break;
 982                 c = bp->sectsize - o;
 983                 if(c > count)
 984                         c = count;
 985                 if(c == bp->sectsize){
 986                         p = getosect(xf, addr);
 987                         p->flags = 0;
 988                 }else{
 989                         p = getsect(xf, addr);
 990                         if(p == nil)
 991                                 return -1;
 992                 }
 993                 memmove(&p->iobuf[o], &buf[rcnt], c);
 994                 p->flags |= BMOD;
 995                 putsect(p);
 996                 count -= c;
 997                 rcnt += c;
 998                 o = 0;
 999         }
1000         if(rcnt <= 0 && addr < 0)
1001                 return -1;
1002         length = 0;
1003         dlen = GLONG(d->length);
1004         if(rcnt > 0)
1005                 length = offset+rcnt;
1006         else if(dp->addr && dp->clust){
1007                 c = bp->clustsize*bp->sectsize;
1008                 if(dp->iclust > (dlen+c-1)/c)
1009                         length = c*dp->iclust;
1010         }
1011         if(length > dlen)
1012                 PLONG(d->length, length);
1013         puttime(d, 0);
1014         dp->p->flags |= BMOD;
1015         return rcnt;
1016 }
1017
1018 int
1019 truncfile(Xfile *f, long length)
1020 {
1021         Xfs *xf = f->xf;
1022         Dosbpb *bp = xf->ptr;
1023         Dosptr *dp = f->ptr;
1024         Dosdir *d = dp->d;
1025         long clust, next, n;
1026
1027         mlock(bp);
1028         clust = getstart(f->xf, d);
1029         n = length;
1030         if(n <= 0)
1031                 putstart(f->xf, d, 0);
1032         else
1033                 n -= bp->sectsize;
1034         while(clust > 0){
1035                 next = getfat(xf, clust);
1036                 if(n <= 0)
1037                         putfat(xf, clust, 0);
1038                 else
1039                         n -= bp->clustsize*bp->sectsize;
1040                 clust = next;
1041         }
1042         unmlock(bp);
1043         PLONG(d->length, length);
1044         dp->iclust = 0;
1045         dp->clust = 0;
1046         dp->p->flags |= BMOD;
1047         return 0;
1048 }
1049
1050 void
1051 putdir(Dosdir *d, Dir *dp)
1052 {
1053         if(dp->mode != ~0){
1054                 if(dp->mode & 2)
1055                         d->attr &= ~DRONLY;
1056                 else
1057                         d->attr |= DRONLY;
1058                 if(dp->mode & DMEXCL)
1059                         d->attr |= DSYSTEM;
1060                 else
1061                         d->attr &= ~DSYSTEM;
1062         }
1063         if(dp->mtime != ~0)
1064                 puttime(d, dp->mtime);
1065 }
1066
1067 /*
1068  * should extend this to deal with
1069  * creation and access dates
1070  */
1071 void
1072 getdir(Xfs *xfs, Dir *dp, Dosdir *d, int addr, int offset)
1073 {
1074         if(d == nil || addr == 0)
1075                 panic("getdir on root");
1076         dp->type = 0;
1077         dp->dev = 0;
1078         getname(dp->name, d);
1079
1080         dp->qid.path = addr*(Sectorsize/DOSDIRSIZE) +
1081                         offset/DOSDIRSIZE;
1082         dp->qid.vers = 0;
1083
1084         if(d->attr & DRONLY)
1085                 dp->mode = 0444;
1086         else
1087                 dp->mode = 0666;
1088         dp->atime = gtime(d);
1089         dp->mtime = dp->atime;
1090         dp->qid.type = QTFILE;
1091         if(d->attr & DDIR){
1092                 dp->qid.type = QTDIR;
1093                 dp->mode |= DMDIR|0111;
1094                 dp->length = 0;
1095         }else
1096                 dp->length = GLONG(d->length);
1097         if(d->attr & DSYSTEM){
1098                 dp->mode |= DMEXCL;
1099                 if(iscontig(xfs, d))
1100                         dp->mode |= DMAPPEND;
1101         }
1102
1103         dp->uid = "bill";
1104         dp->muid = "bill";
1105         dp->gid = "trog";
1106 }
1107
1108 void
1109 getname(char *p, Dosdir *d)
1110 {
1111         int c, i;
1112
1113         for(i=0; i<8; i++){
1114                 c = d->name[i];
1115                 if(c == '\0' || c == ' ')
1116                         break;
1117                 if(i == 0 && c == 0x05)
1118                         c = 0xe5;
1119                 *p++ = c;
1120         }
1121         for(i=0; i<3; i++){
1122                 c = d->ext[i];
1123                 if(c == '\0' || c == ' ')
1124                         break;
1125                 if(i == 0)
1126                         *p++ = '.';
1127                 *p++ = c;
1128         }
1129         *p = 0;
1130 }
1131
1132 static char*
1133 getnamerunes(char *dst, uchar *buf, int step)
1134 {
1135         int i;
1136         Rune r;
1137         char dbuf[DOSRUNE * UTFmax + 1], *d;
1138
1139         d = dbuf;
1140         r = 1;
1141         for(i = 1; r && i < 11; i += 2){
1142                 r = buf[i] | (buf[i+1] << 8);
1143                 d += runetochar(d, &r);
1144         }
1145         for(i = 14; r && i < 26; i += 2){
1146                 r = buf[i] | (buf[i+1] << 8);
1147                 d += runetochar(d, &r);
1148         }
1149         for(i = 28; r && i < 32; i += 2){
1150                 r = buf[i] | (buf[i+1] << 8);
1151                 d += runetochar(d, &r);
1152         }
1153
1154         if(step == 1)
1155                 dst -= d - dbuf;
1156
1157         memmove(dst, dbuf, d - dbuf);
1158
1159         if(step == -1){
1160                 dst += d - dbuf;
1161                 *dst = '\0';
1162         }
1163
1164         return dst;
1165 }
1166
1167 char*
1168 getnamesect(char *dbuf, char *d, uchar *buf, int *islong, int *sum, int step)
1169 {
1170         /*
1171          * validation checks to make sure we're
1172          * making up a consistent name
1173          */
1174         if(buf[11] != 0xf || buf[12] != 0){
1175                 *islong = 0;
1176                 return nil;
1177         }
1178         if(step == 1){
1179                 if((buf[0] & 0xc0) == 0x40){
1180                         *islong = buf[0] & 0x3f;
1181                         *sum = buf[13];
1182                         d = dbuf + DOSNAMELEN;
1183                         *--d = '\0';
1184                 }else if(*islong && *islong == buf[0] + 1 && *sum == buf[13]){
1185                         *islong = buf[0];
1186                 }else{
1187                         *islong = 0;
1188                         return nil;
1189                 }
1190         }else{
1191                 if(*islong + 1 == (buf[0] & 0xbf) && *sum == buf[13]){
1192                         *islong = buf[0] & 0x3f;
1193                         if(buf[0] & 0x40)
1194                                 *sum = -1;
1195                 }else{
1196                         *islong = 0;
1197                         *sum = -1;
1198                         return nil;
1199                 }
1200         }
1201         if(*islong > 20){
1202                 *islong = 0;
1203                 *sum = -1;
1204                 return nil;
1205         }
1206
1207         return getnamerunes(d, buf, step);
1208 }
1209
1210 void
1211 putname(char *p, Dosdir *d)
1212 {
1213         int i;
1214
1215         memset(d->name, ' ', sizeof d->name+sizeof d->ext);
1216         for(i=0; i<sizeof d->name; i++){
1217                 if(*p == 0 || *p == '.')
1218                         break;
1219                 d->name[i] = toupper(*p++);
1220         }
1221         p = strrchr(p, '.');
1222         if(p){
1223                 for(i=0; i<sizeof d->ext; i++){
1224                         if(*++p == 0)
1225                                 break;
1226                         d->ext[i] = toupper(*p);
1227                 }
1228         }
1229 }
1230
1231 static void
1232 putnamesect(uchar *slot, Rune *longname, int curslot, int first, int sum)
1233 {
1234         Rune r;
1235         Dosdir ds;
1236         int i, j;
1237
1238         memset(&ds, 0xff, sizeof ds);
1239         ds.attr = 0xf;
1240         ds.reserved[0] = 0;
1241         ds.reserved[1] = sum;
1242         ds.start[0] = 0;
1243         ds.start[1] = 0;
1244         if(first)
1245                 ds.name[0] = 0x40 | curslot;
1246         else
1247                 ds.name[0] = curslot;
1248         memmove(slot, &ds, sizeof ds);
1249
1250         j = (curslot-1) * DOSRUNE;
1251
1252         for(i = 1; i < 11; i += 2){
1253                 r = longname[j++];
1254                 slot[i] = r;
1255                 slot[i+1] = r >> 8;
1256                 if(r == 0)
1257                         return;
1258         }
1259         for(i = 14; i < 26; i += 2){
1260                 r = longname[j++];
1261                 slot[i] = r;
1262                 slot[i+1] = r >> 8;
1263                 if(r == 0)
1264                         return;
1265         }
1266         for(i = 28; i < 32; i += 2){
1267                 r = longname[j++];
1268                 slot[i] = r;
1269                 slot[i+1] = r >> 8;
1270                 if(r == 0)
1271                         return;
1272         }
1273 }
1274
1275 int
1276 aliassum(Dosdir *d)
1277 {
1278         int i, sum;
1279
1280         if(d == nil)
1281                 return -1;
1282         sum = 0;
1283         for(i = 0; i < 11; i++)
1284                 sum = (((sum&1)<<7) | ((sum&0xfe)>>1)) + d->name[i];
1285         return sum & 0xff;
1286 }
1287
1288 int
1289 putlongname(Xfs *xf, Dosptr *ndp, char *name, char sname[13])
1290 {
1291         Dosbpb *bp;
1292         Dosdir tmpd;
1293         Rune longname[DOSNAMELEN+1];
1294         int i, first, sum, nds, len;
1295
1296         /* calculate checksum */
1297         putname(sname, &tmpd);
1298         sum = aliassum(&tmpd);
1299
1300         bp = xf->ptr;
1301         first = 1;
1302         len = utftorunes(longname, name, DOSNAMELEN);
1303         if(chatty){
1304                 chat("utftorunes %s =", name);
1305                 for(i=0; i<len; i++)
1306                         chat(" %.4X", longname[i]);
1307                 chat("\n");
1308         }
1309         for(nds = (len + DOSRUNE-1) / DOSRUNE; nds > 0; nds--){
1310                 putnamesect(&ndp->p->iobuf[ndp->offset], longname, nds, first, sum);
1311                 first = 0;
1312                 ndp->offset += 32;
1313                 if(ndp->offset == bp->sectsize){
1314                         chat("long name moving over sector boundary\n");
1315                         ndp->p->flags |= BMOD;
1316                         putsect(ndp->p);
1317                         ndp->p = nil;
1318
1319                         /*
1320                          * switch to the next cluster for a long entry
1321                          * naddr should be set up correctly by searchdir
1322                          */
1323                         ndp->prevaddr = ndp->addr;
1324                         ndp->addr = ndp->naddr;
1325                         ndp->naddr = -1;
1326                         if(ndp->addr == -1)
1327                                 return -1;
1328                         ndp->p = getsect(xf, ndp->addr);
1329                         if(ndp->p == nil)
1330                                 return -1;
1331                         ndp->offset = 0;
1332                         ndp->d = (Dosdir *)&ndp->p->iobuf[ndp->offset];
1333                 }
1334         }
1335         return 0;
1336 }
1337
1338 long
1339 getfat(Xfs *xf, int n)
1340 {
1341         Dosbpb *bp = xf->ptr;
1342         Iosect *p;
1343         ulong k, sect;
1344         int o, fb;
1345
1346         if(n < FATRESRV || n >= bp->fatclusters)
1347                 return -1;
1348         fb = bp->fatbits;
1349         k = (fb * n) >> 3;
1350         if(k >= bp->fatsize*bp->sectsize)
1351                 panic("getfat");
1352         sect = k/bp->sectsize + bp->fataddr;
1353         o = k%bp->sectsize;
1354         p = getsect(xf, sect);
1355         if(p == nil)
1356                 return -1;
1357         k = p->iobuf[o++];
1358         if(o >= bp->sectsize){
1359                 putsect(p);
1360                 p = getsect(xf, sect+1);
1361                 if(p == nil)
1362                         return -1;
1363                 o = 0;
1364         }
1365         k |= p->iobuf[o++]<<8;
1366         if(fb == 32){
1367                 /* fat32 is really fat28 */
1368                 k |= p->iobuf[o++] << 16;
1369                 k |= (p->iobuf[o] & 0x0f) << 24;
1370                 fb = 28;
1371         }
1372         putsect(p);
1373         if(fb == 12){
1374                 if(n&1)
1375                         k >>= 4;
1376                 else
1377                         k &= 0xfff;
1378         }
1379         if(chatty > 1)
1380                 chat("fat(%#x)=%#lx...", n, k);
1381
1382         /*
1383          * This is a very strange check for out of range.
1384          * As a concrete example, for a 16-bit FAT,
1385          * FFF8 through FFFF all signify ``end of cluster chain.''
1386          * This generalizes to other-sized FATs.
1387          */
1388         if(k >= (1 << fb) - 8)
1389                 return -1;
1390
1391         return k;
1392 }
1393
1394 void
1395 putfat(Xfs *xf, int n, ulong val)
1396 {
1397         Fatinfo *fi;
1398         Dosbpb *bp;
1399         Iosect *p;
1400         ulong k, sect, esect;
1401         int o;
1402
1403         bp = xf->ptr;
1404         if(n < FATRESRV || n >= bp->fatclusters)
1405                 panic("putfat n=%d", n);
1406         k = (bp->fatbits * n) >> 3;
1407         if(k >= bp->fatsize*bp->sectsize)
1408                 panic("putfat");
1409         sect = k/bp->sectsize + bp->fataddr;
1410         esect = sect + bp->nfats * bp->fatsize;
1411         for(; sect<esect; sect+=bp->fatsize){
1412                 o = k%bp->sectsize;
1413                 p = getsect(xf, sect);
1414                 if(p == nil)
1415                         continue;
1416                 switch(bp->fatbits){
1417                 case 12:
1418                         if(n&1){
1419                                 p->iobuf[o] &= 0x0f;
1420                                 p->iobuf[o++] |= val<<4;
1421                                 if(o >= bp->sectsize){
1422                                         p->flags |= BMOD;
1423                                         putsect(p);
1424                                         p = getsect(xf, sect+1);
1425                                         if(p == nil)
1426                                                 continue;
1427                                         o = 0;
1428                                 }
1429                                 p->iobuf[o] = val>>4;
1430                         }else{
1431                                 p->iobuf[o++] = val;
1432                                 if(o >= bp->sectsize){
1433                                         p->flags |= BMOD;
1434                                         putsect(p);
1435                                         p = getsect(xf, sect+1);
1436                                         if(p == nil)
1437                                                 continue;
1438                                         o = 0;
1439                                 }
1440                                 p->iobuf[o] &= 0xf0;
1441                                 p->iobuf[o] |= (val>>8) & 0x0f;
1442                         }
1443                         break;
1444                 case 16:
1445                         p->iobuf[o++] = val;
1446                         p->iobuf[o] = val>>8;
1447                         break;
1448                 case 32:        /* fat32 is really fat28 */
1449                         p->iobuf[o++] = val;
1450                         p->iobuf[o++] = val>>8;
1451                         p->iobuf[o++] = val>>16;
1452                         p->iobuf[o] = (p->iobuf[o] & 0xf0) | ((val>>24) & 0x0f);
1453                         break;
1454                 default:
1455                         panic("putfat fatbits");
1456                 }
1457                 p->flags |= BMOD;
1458                 putsect(p);
1459         }
1460
1461         if(val == 0)
1462                 bp->freeclusters++;
1463         else
1464                 bp->freeclusters--;
1465
1466         if(bp->fatinfo){
1467                 p = getsect(xf, bp->fatinfo);
1468                 if(p != nil){
1469                         fi = (Fatinfo*)p->iobuf;
1470                         PLONG(fi->nextfree, bp->freeptr);
1471                         PLONG(fi->freeclust, bp->freeclusters);
1472                         p->flags |= BMOD;
1473                         putsect(p);
1474                 }
1475         }
1476 }
1477
1478 /*
1479  * Contiguous falloc; if we can, use lastclust+1.
1480  * Otherwise, move the file to get some space.
1481  * If there just isn't enough contiguous space
1482  * anywhere on disk, fail.
1483  */
1484 int
1485 cfalloc(Xfile *f)
1486 {
1487         int l;
1488
1489         if((l=makecontig(f, 8)) >= 0)
1490                 return l;
1491         return makecontig(f, 1);
1492 }
1493
1494 /*
1495  * Check whether a file is contiguous.
1496  */
1497 int
1498 iscontig(Xfs *xf, Dosdir *d)
1499 {
1500         long clust, next;
1501
1502         clust = getstart(xf, d);
1503         if(clust <= 0)
1504                 return 1;
1505
1506         for(;;) {
1507                 next = getfat(xf, clust);
1508                 if(next < 0)
1509                         return 1;
1510                 if(next != clust+1)
1511                         return 0;
1512                 clust = next;
1513         }
1514 }
1515
1516 /*
1517  * Make a file contiguous, with nextra clusters of
1518  * free space after it for later expansion.
1519  * Return the number of the first new cluster.
1520  */
1521 int
1522 makecontig(Xfile *f, int nextra)
1523 {
1524         Dosbpb *bp;
1525         Dosdir *d;
1526         Dosptr *dp;
1527         Xfs *xf;
1528         Iosect *wp, *rp;
1529         long clust, next, last, start, rclust, wclust, eclust, ostart;
1530         int isok, i, n, nclust, nrun, rs, ws;
1531
1532         xf = f->xf;
1533         bp = xf->ptr;
1534         dp = f->ptr;
1535         d = dp->d;
1536
1537         isok = 1;
1538         nclust = 0;
1539         clust = fileclust(f, 0, 0);
1540         chat("clust %#lux", clust);
1541         if(clust != -1) {
1542                 for(;;) {
1543                         nclust++;
1544                         chat(".");
1545                         next = getfat(xf, clust);
1546                         if(next <= 0)
1547                                 break;
1548                         if(next != clust+1)
1549                                 isok = 0;
1550                         clust = next;
1551                 }
1552         }
1553         chat("nclust %d\n", nclust);
1554
1555         if(isok && clust != -1) {
1556                 eclust = clust+1;       /* eclust = first cluster past file */
1557                 assert(eclust == fileclust(f, 0, 0)+nclust);
1558                 for(i=0; i<nextra; i++)
1559                         if(getfat(xf, eclust+i) != 0)
1560                                 break;
1561                 if(i == nextra) {       /* they were all free */
1562                         chat("eclust=%#lx, getfat eclust-1 = %#lux\n", eclust, getfat(xf, eclust-1));
1563                         assert(getfat(xf, eclust-1) == 0xffffffff);
1564                         putfat(xf, eclust-1, eclust);
1565                         putfat(xf, eclust, 0xffffffff);
1566                         bp->freeptr = clust+1;  /* to help keep the blocks free */
1567                         return eclust;
1568                 }
1569         }
1570
1571         /* need to search for nclust+nextra contiguous free blocks */
1572         last = -1;
1573         n = bp->freeptr;
1574         nrun = 0;
1575         for(;;){
1576                 if(getfat(xf, n) == 0) {
1577                         if(last+1 == n)
1578                                 nrun++;
1579                         else
1580                                 nrun = 1;
1581                         if(nrun >= nclust+nextra)
1582                                 break;
1583                         last = n;
1584                 }
1585                 if(++n >= bp->fatclusters)
1586                         n = FATRESRV;
1587                 if(n == bp->freeptr) {
1588                         errno = Econtig;
1589                         return -1;
1590                 }
1591         }
1592         bp->freeptr = n+1;
1593
1594         /* copy old data over */
1595         start = n+1 - nrun;
1596
1597         /* sanity check */
1598         for(i=0; i<nclust+nextra; i++)
1599                 assert(getfat(xf, start+i) == 0);
1600
1601         chat("relocate chain %lux -> 0x%lux len %d\n", fileclust(f, 0, 0), start, nclust);
1602
1603         wclust = start;
1604         for(rclust = fileclust(f, 0, 0); rclust > 0; rclust = next){
1605                 rs = clust2sect(bp, rclust);
1606                 ws = clust2sect(bp, wclust);
1607                 for(i=0; i<bp->clustsize; i++, rs++, ws++){
1608                         rp = getsect(xf, rs);
1609                         if(rp == nil)
1610                                 return -1;
1611                         wp = getosect(xf, ws);
1612                         assert(wp != nil);
1613                         memmove(wp->iobuf, rp->iobuf, bp->sectsize);
1614                         wp->flags = BMOD;
1615                         putsect(rp);
1616                         putsect(wp);
1617                 }
1618                 chat("move cluster %#lx -> %#lx...", rclust, wclust);
1619                 next = getfat(xf, rclust);
1620                 putfat(xf, wclust, wclust+1);
1621                 wclust++;
1622         }
1623
1624         /* now wclust points at the first new cluster; chain it in */
1625         chat("wclust 0x%lux start 0x%lux (fat->0x%lux) nclust %d\n", wclust, start, getfat(xf, start), nclust);
1626         assert(wclust == start+nclust);
1627         putfat(xf, wclust, 0xffffffff); /* end of file */
1628
1629         /* update directory entry to point at new start */
1630         ostart = fileclust(f, 0, 0);
1631         putstart(xf, d, start);
1632
1633         /* check our work */
1634         i = 0;
1635         clust = fileclust(f, 0, 0);
1636         if(clust != -1) {
1637                 for(;;) {
1638                         i++;
1639                         next = getfat(xf, clust);
1640                         if(next <= 0)
1641                                 break;
1642                         assert(next == clust+1);
1643                         clust = next;
1644                 }
1645         }
1646         chat("chain check: len %d\n", i);
1647         assert(i == nclust+1);
1648
1649         /* succeeded; remove old chain. */
1650         for(rclust = ostart; rclust > 0; rclust = next){
1651                 next = getfat(xf, rclust);
1652                 putfat(xf, rclust, 0);  /* free cluster */
1653         }
1654
1655         return start+nclust;
1656 }
1657
1658 int
1659 falloc(Xfs *xf)
1660 {
1661         Dosbpb *bp = xf->ptr;
1662         Iosect *p;
1663         int n, i, k;
1664
1665         n = bp->freeptr;
1666         for(;;){
1667                 if(getfat(xf, n) == 0)
1668                         break;
1669                 if(++n >= bp->fatclusters)
1670                         n = FATRESRV;
1671                 if(n == bp->freeptr)
1672                         return -1;
1673         }
1674         bp->freeptr = n+1;
1675         if(bp->freeptr >= bp->fatclusters)
1676                 bp->freeptr = FATRESRV;
1677         putfat(xf, n, 0xffffffff);
1678         k = clust2sect(bp, n);
1679         for(i=0; i<bp->clustsize; i++){
1680                 p = getosect(xf, k+i);
1681                 memset(p->iobuf, 0, bp->sectsize);
1682                 p->flags = BMOD;
1683                 putsect(p);
1684         }
1685         return n;
1686 }
1687
1688 void
1689 ffree(Xfs *xf, long start)
1690 {
1691         putfat(xf, start, 0);
1692 }
1693
1694 long
1695 clust2sect(Dosbpb *bp, long clust)
1696 {
1697         return bp->dataaddr + (clust - FATRESRV) * bp->clustsize;
1698 }
1699
1700 long
1701 sect2clust(Dosbpb *bp, long sect)
1702 {
1703         long c;
1704
1705         c = (sect - bp->dataaddr) / bp->clustsize + FATRESRV;
1706         assert(sect == clust2sect(bp, c));
1707         return c;
1708 }
1709
1710 void
1711 puttime(Dosdir *d, long s)
1712 {
1713         Tm *t;
1714         ushort x;
1715
1716         if(s == 0)
1717                 s = time(0);
1718         t = localtime(s);
1719
1720         x = (t->hour<<11) | (t->min<<5) | (t->sec>>1);
1721         PSHORT(d->time, x);
1722         x = ((t->year-80)<<9) | ((t->mon+1)<<5) | t->mday;
1723         PSHORT(d->date, x);
1724 }
1725
1726 long
1727 gtime(Dosdir *dp)
1728 {
1729         Tm tm;
1730         int i;
1731
1732         i = GSHORT(dp->time);
1733         tm.hour = i >> 11;
1734         tm.min = (i >> 5) & 63;
1735         tm.sec = (i & 31) << 1;
1736         i = GSHORT(dp->date);
1737         tm.year = 80 + (i >> 9);
1738         tm.mon = ((i >> 5) & 15) - 1;
1739         tm.mday = i & 31;
1740         tm.zone[0] = '\0';
1741         tm.tzoff = 0;
1742         tm.yday = 0;
1743
1744         return tm2sec(&tm);
1745 }
1746
1747 /*
1748  * structure dumps for debugging
1749  */
1750 void
1751 bootdump(int fd, Dosboot *b)
1752 {
1753         Biobuf bp;
1754
1755         Binit(&bp, fd, OWRITE);
1756         Bprint(&bp, "magic: 0x%2.2x 0x%2.2x 0x%2.2x\n",
1757                 b->magic[0], b->magic[1], b->magic[2]);
1758         Bprint(&bp, "version: \"%8.8s\"\n", (char*)b->version);
1759         Bprint(&bp, "sectsize: %d\n", GSHORT(b->sectsize));
1760         Bprint(&bp, "clustsize: %d\n", b->clustsize);
1761         Bprint(&bp, "nresrv: %d\n", GSHORT(b->nresrv));
1762         Bprint(&bp, "nfats: %d\n", b->nfats);
1763         Bprint(&bp, "rootsize: %d\n", GSHORT(b->rootsize));
1764         Bprint(&bp, "volsize: %d\n", GSHORT(b->volsize));
1765         Bprint(&bp, "mediadesc: 0x%2.2x\n", b->mediadesc);
1766         Bprint(&bp, "fatsize: %d\n", GSHORT(b->fatsize));
1767         Bprint(&bp, "trksize: %d\n", GSHORT(b->trksize));
1768         Bprint(&bp, "nheads: %d\n", GSHORT(b->nheads));
1769         Bprint(&bp, "nhidden: %ld\n", GLONG(b->nhidden));
1770         Bprint(&bp, "bigvolsize: %ld\n", GLONG(b->bigvolsize));
1771         Bprint(&bp, "driveno: %d\n", b->driveno);
1772         Bprint(&bp, "reserved0: 0x%2.2x\n", b->reserved0);
1773         Bprint(&bp, "bootsig: 0x%2.2x\n", b->bootsig);
1774         Bprint(&bp, "volid: 0x%8.8lux\n", GLONG(b->volid));
1775         Bprint(&bp, "label: \"%11.11s\"\n", (char*)b->label);
1776         Bterm(&bp);
1777 }
1778
1779 void
1780 bootdump32(int fd, Dosboot32 *b)
1781 {
1782         Biobuf bp;
1783
1784         Binit(&bp, fd, OWRITE);
1785         Bprint(&bp, "magic: 0x%2.2x 0x%2.2x 0x%2.2x\n",
1786                 b->magic[0], b->magic[1], b->magic[2]);
1787         Bprint(&bp, "version: \"%8.8s\"\n", (char*)b->version);
1788         Bprint(&bp, "sectsize: %d\n", GSHORT(b->sectsize));
1789         Bprint(&bp, "clustsize: %d\n", b->clustsize);
1790         Bprint(&bp, "nresrv: %d\n", GSHORT(b->nresrv));
1791         Bprint(&bp, "nfats: %d\n", b->nfats);
1792         Bprint(&bp, "rootsize: %d\n", GSHORT(b->rootsize));
1793         Bprint(&bp, "volsize: %d\n", GSHORT(b->volsize));
1794         Bprint(&bp, "mediadesc: 0x%2.2x\n", b->mediadesc);
1795         Bprint(&bp, "fatsize: %d\n", GSHORT(b->fatsize));
1796         Bprint(&bp, "trksize: %d\n", GSHORT(b->trksize));
1797         Bprint(&bp, "nheads: %d\n", GSHORT(b->nheads));
1798         Bprint(&bp, "nhidden: %ld\n", GLONG(b->nhidden));
1799         Bprint(&bp, "bigvolsize: %ld\n", GLONG(b->bigvolsize));
1800         Bprint(&bp, "fatsize32: %ld\n", GLONG(b->fatsize32));
1801         Bprint(&bp, "extflags: %d\n", GSHORT(b->extflags));
1802         Bprint(&bp, "version: %d\n", GSHORT(b->version1));
1803         Bprint(&bp, "rootstart: %ld\n", GLONG(b->rootstart));
1804         Bprint(&bp, "infospec: %d\n", GSHORT(b->infospec));
1805         Bprint(&bp, "backupboot: %d\n", GSHORT(b->backupboot));
1806         Bprint(&bp, "reserved: %d %d %d %d %d %d %d %d %d %d %d %d\n",
1807                 b->reserved[0], b->reserved[1], b->reserved[2], b->reserved[3],
1808                 b->reserved[4], b->reserved[5], b->reserved[6], b->reserved[7],
1809                 b->reserved[8], b->reserved[9], b->reserved[10], b->reserved[11]);
1810         Bterm(&bp);
1811 }
1812
1813 void
1814 bootsecdump32(int fd, Xfs *xf, Dosboot32 *b32)
1815 {
1816         Fatinfo *fi;
1817         Iosect *p1;
1818         int fisec, bsec, res;
1819
1820         fprint(fd, "\nfat32\n");
1821         bootdump32(fd, b32);
1822         res = GSHORT(b32->nresrv);
1823         bsec = GSHORT(b32->backupboot);
1824         if(bsec < res && bsec != 0){
1825                 p1 = getsect(xf, bsec);
1826                 if(p1 == nil)
1827                         fprint(fd, "\ncouldn't get backup boot sector: %r\n");
1828                 else{
1829                         fprint(fd, "\nbackup boot\n");
1830                         bootdump32(fd, (Dosboot32*)p1->iobuf);
1831                         putsect(p1);
1832                 }
1833         }else if(bsec != 0xffff)
1834                 fprint(fd, "bad backup boot sector: %d reserved %d\n", bsec, res);
1835         fisec = GSHORT(b32->infospec);
1836         if(fisec < res && fisec != 0){
1837                 p1 = getsect(xf, fisec);
1838                 if(p1 == nil)
1839                         fprint(fd, "\ncouldn't get fat info sector: %r\n");
1840                 else{
1841                         fprint(fd, "\nfat info %d\n", fisec);
1842                         fi = (Fatinfo*)p1->iobuf;
1843                         fprint(fd, "sig1: 0x%lux sb 0x%lux\n", GLONG(fi->sig1), FATINFOSIG1);
1844                         fprint(fd, "sig: 0x%lux sb 0x%lux\n", GLONG(fi->sig), FATINFOSIG);
1845                         fprint(fd, "freeclust: %lud\n", GLONG(fi->freeclust));
1846                         fprint(fd, "nextfree: %lud\n", GLONG(fi->nextfree));
1847                         fprint(fd, "reserved: %lud %lud %lud\n", GLONG(fi->resrv), GLONG(fi->resrv+4), GLONG(fi->resrv+8));
1848                         putsect(p1);
1849                 }
1850         }else if(fisec != 0xffff)
1851                 fprint(2, "bad fat info sector: %d reserved %d\n", bsec, res);
1852 }
1853
1854 void
1855 dirdump(void *vdbuf)
1856 {
1857         static char attrchar[] = "rhsvda67";
1858         Dosdir *d;
1859         char *name, namebuf[DOSNAMELEN];
1860         char buf[128], *s, *ebuf;
1861         uchar *dbuf;
1862         int i;
1863
1864         if(!chatty)
1865                 return;
1866
1867         d = vdbuf;
1868
1869         ebuf = buf + sizeof(buf);
1870         if(d->attr == 0xf){
1871                 dbuf = vdbuf;
1872                 name = namebuf + DOSNAMELEN;
1873                 *--name = '\0';
1874                 name = getnamerunes(name, dbuf, 1);
1875                 seprint(buf, ebuf, "\"%s\" %2.2x %2.2ux %2.2ux %d", name, dbuf[0], dbuf[12], dbuf[13], GSHORT(d->start));
1876         }else{
1877                 s = seprint(buf, ebuf, "\"%.8s.%.3s\" ", (char*)d->name, (char*)d->ext);
1878                 for(i=7; i>=0; i--)
1879                         *s++ = d->attr&(1<<i) ? attrchar[i] : '-';
1880
1881                 i = GSHORT(d->time);
1882                 s = seprint(s, ebuf, " %2.2d:%2.2d:%2.2d", i>>11, (i>>5)&63, (i&31)<<1);
1883                 i = GSHORT(d->date);
1884                 s = seprint(s, ebuf, " %2.2d.%2.2d.%2.2d", 80+(i>>9), (i>>5)&15, i&31);
1885
1886                 i = GSHORT(d->ctime);
1887                 s = seprint(s, ebuf, " %2.2d:%2.2d:%2.2d", i>>11, (i>>5)&63, (i&31)<<1);
1888                 i = GSHORT(d->cdate);
1889                 s = seprint(s, ebuf, " %2.2d.%2.2d.%2.2d", 80+(i>>9), (i>>5)&15, i&31);
1890
1891                 i = GSHORT(d->adate);
1892                 s = seprint(s, ebuf, " %2.2d.%2.2d.%2.2d", 80+(i>>9), (i>>5)&15, i&31);
1893
1894                 seprint(s, ebuf, " %d %d", GSHORT(d->start), GSHORT(d->length));
1895         }
1896         chat("%s\n", buf);
1897 }
1898
1899 int
1900 cistrcmp(char *s1, char *s2)
1901 {
1902         int c1, c2;
1903
1904         while(*s1){
1905                 c1 = *s1++;
1906                 c2 = *s2++;
1907
1908                 if(c1 >= 'A' && c1 <= 'Z')
1909                         c1 -= 'A' - 'a';
1910
1911                 if(c2 >= 'A' && c2 <= 'Z')
1912                         c2 -= 'A' - 'a';
1913
1914                 if(c1 != c2)
1915                         return c1 - c2;
1916         }
1917         return -*s2;
1918 }
1919
1920 int
1921 utftorunes(Rune *rr, char *s, int n)
1922 {
1923         Rune *r, *re;
1924         int c;
1925
1926         r = rr;
1927         re = r + n - 1;
1928         while(c = (uchar)*s){
1929                 if(c < Runeself){
1930                         *r = c;
1931                         s++;
1932                 }else
1933                         s += chartorune(r, s);
1934                 r++;
1935                 if(r >= re)
1936                         break;
1937         }
1938         *r = 0;
1939         return r - rr;
1940 }