sys/lib/libsa/dosfs.c

   1 /*      $NetBSD: dosfs.c,v 1.19 2013/10/20 17:15:42 christos Exp $      */
   2
   3 /*
   4  * Copyright (c) 1996, 1998 Robert Nordier
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS
  18  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /*
  31  * Readonly filesystem for Microsoft FAT12/FAT16/FAT32 filesystems,
  32  * also supports VFAT.
  33  */
  34
  35 /*
  36  * XXX DOES NOT SUPPORT:
  37  *
  38  *      LIBSA_FS_SINGLECOMPONENT
  39  */
  40
  41 #include <sys/param.h>
  42
  43 #include <fs/msdosfs/bpb.h>
  44 #include <fs/msdosfs/direntry.h>
  45
  46 #ifdef _STANDALONE
  47 #include <lib/libkern/libkern.h>
  48 #else
  49 #include <string.h>
  50 #include <stddef.h>
  51 #endif
  52
  53 #include "stand.h"
  54 #include "dosfs.h"
  55
  56 #define SECSIZ  512             /* sector size */
  57 #define SSHIFT    9             /* SECSIZ shift */
  58 #define DEPSEC   16             /* directory entries per sector */
  59 #define DSHIFT    4             /* DEPSEC shift */
  60 #define LOCLUS    2             /* lowest cluster number */
  61
  62 typedef union {
  63         struct direntry de;     /* standard directory entry */
  64         struct winentry xde;    /* extended directory entry */
  65 } DOS_DIR;
  66
  67 typedef struct {
  68         struct open_file *fd;   /* file descriptor */
  69         u_char *buf;            /* buffer */
  70         u_int   bufsec;         /* buffered sector */
  71         u_int   links;          /* active links to structure */
  72         u_int   spc;            /* sectors per cluster */
  73         u_int   bsize;          /* cluster size in bytes */
  74         u_int   bshift;         /* cluster conversion shift */
  75         u_int   dirents;        /* root directory entries */
  76         u_int   spf;            /* sectors per fat */
  77         u_int   rdcl;           /* root directory start cluster */
  78         u_int   lsnfat;         /* start of fat */
  79         u_int   lsndir;         /* start of root dir */
  80         u_int   lsndta;         /* start of data area */
  81         u_int   fatsz;          /* FAT entry size */
  82         u_int   xclus;          /* maximum cluster number */
  83 } DOS_FS;
  84
  85 typedef struct {
  86         DOS_FS *fs;             /* associated filesystem */
  87         struct direntry de;     /* directory entry */
  88         u_int   offset;         /* current offset */
  89         u_int   c;              /* last cluster read */
  90 } DOS_FILE;
  91
  92 /* Initial portion of DOS boot sector */
  93 typedef struct {
  94         u_char  jmp[3];         /* usually 80x86 'jmp' opcode */
  95         u_char  oem[8];         /* OEM name and version */
  96         struct byte_bpb710 bpb; /* BPB */
  97 } DOS_BS;
  98
  99 /* Supply missing "." and ".." root directory entries */
 100 static const char *const dotstr[2] = {".", ".."};
 101 static const struct direntry dot[2] = {
 102         {".       ", "   ", ATTR_DIRECTORY,
 103                 0, 0, {0, 0}, {0, 0}, {0, 0}, {0, 0},
 104                 {0, 0}, {0x21, 0}, {0, 0}, {0, 0, 0, 0}},
 105
 106         {"..      ", "   ", ATTR_DIRECTORY,
 107                 0, 0, {0, 0}, {0, 0}, {0, 0}, {0, 0},
 108                 {0, 0}, {0x21, 0}, {0, 0}, {0, 0, 0, 0}}
 109 };
 110
 111 /* The usual conversion macros to avoid multiplication and division */
 112 #define bytsec(n)      ((n) >> SSHIFT)
 113 #define secbyt(s)      ((s) << SSHIFT)
 114 #define entsec(e)      ((e) >> DSHIFT)
 115 #define bytblk(fs, n)  ((n) >> (fs)->bshift)
 116 #define blkbyt(fs, b)  ((b) << (fs)->bshift)
 117 #define secblk(fs, s)  ((s) >> ((fs)->bshift - SSHIFT))
 118 #define blksec(fs, b)  ((b) << ((fs)->bshift - SSHIFT))
 119
 120 /* Convert cluster number to offset within filesystem */
 121 #define blkoff(fs, b) (secbyt((fs)->lsndta) + blkbyt(fs, (b) - LOCLUS))
 122
 123 /* Convert cluster number to logical sector number */
 124 #define blklsn(fs, b)  ((fs)->lsndta + blksec(fs, (b) - LOCLUS))
 125
 126 /* Convert cluster number to offset within FAT */
 127 #define fatoff(sz, c)  ((sz) == 12 ? (c) + ((c) >> 1) :  \
 128                         (sz) == 16 ? (c) << 1 :          \
 129                         (c) << 2)
 130
 131 /* Does cluster number reference a valid data cluster? */
 132 #define okclus(fs, c)  ((c) >= LOCLUS && (c) <= (fs)->xclus)
 133
 134 /* Get start cluster from directory entry */
 135 #define stclus(sz, de)  ((sz) != 32 ? (u_int)getushort((de)->deStartCluster) : \
 136                          ((u_int)getushort((de)->deHighClust) << 16) |  \
 137                          (u_int)getushort((de)->deStartCluster))
 138
 139 static int dosunmount(DOS_FS *);
 140 static int parsebs(DOS_FS *, DOS_BS *);
 141 static int namede(DOS_FS *, const char *, const struct direntry **);
 142 static int lookup(DOS_FS *, u_int, const char *, const struct direntry **);
 143 static void cp_xdnm(u_char *, struct winentry *);
 144 static void cp_sfn(u_char *, struct direntry *);
 145 static off_t fsize(DOS_FS *, struct direntry *);
 146 static int fatcnt(DOS_FS *, u_int);
 147 static int fatget(DOS_FS *, u_int *);
 148 static int fatend(u_int, u_int);
 149 static int ioread(DOS_FS *, u_int, void *, u_int);
 150 static int iobuf(DOS_FS *, u_int);
 151 static int ioget(struct open_file *, u_int, void *, u_int);
 152
 153 #define strcasecmp(s1, s2) dos_strcasecmp(s1, s2)
 154 static int
 155 strcasecmp(const char *s1, const char *s2)
 156 {
 157         char c1, c2;
 158         #define TO_UPPER(c) ((c) >= 'a' && (c) <= 'z' ? (c) - ('a' - 'A') : (c))
 159         for (;;) {
 160                 c1 = *s1++;
 161                 c2 = *s2++;
 162                 if (TO_UPPER(c1) != TO_UPPER(c2))
 163                         return 1;
 164                 if (c1 == 0)
 165                         return 0;
 166         }
 167         #undef TO_UPPER
 168 }
 169
 170 /*
 171  * Mount DOS filesystem
 172  */
 173 static int
 174 dos_mount(DOS_FS *fs, struct open_file *fd)
 175 {
 176         int     err;
 177
 178         (void)memset(fs, 0, sizeof(DOS_FS));
 179         fs->fd = fd;
 180         if ((err = !(fs->buf = alloc(SECSIZ)) ? errno : 0) ||
 181             (err = ioget(fs->fd, 0, fs->buf, 1)) ||
 182             (err = parsebs(fs, (DOS_BS *)fs->buf))) {
 183                 (void) dosunmount(fs);
 184                 return err;
 185         }
 186         return 0;
 187 }
 188
 189 #ifndef LIBSA_NO_FS_CLOSE
 190 /*
 191  * Unmount mounted filesystem
 192  */
 193 static int
 194 dos_unmount(DOS_FS *fs)
 195 {
 196         int     err;
 197
 198         if (fs->links)
 199                 return EBUSY;
 200         if ((err = dosunmount(fs)))
 201                 return err;
 202         return 0;
 203 }
 204 #endif
 205
 206 /*
 207  * Common code shared by dos_mount() and dos_unmount()
 208  */
 209 static int
 210 dosunmount(DOS_FS *fs)
 211 {
 212         if (fs->buf)
 213                 dealloc(fs->buf, SECSIZ);
 214         dealloc(fs, sizeof(DOS_FS));
 215         return 0;
 216 }
 217
 218 /*
 219  * Open DOS file
 220  */
 221 __compactcall int
 222 dosfs_open(const char *path, struct open_file *fd)
 223 {
 224         const struct direntry *de;
 225         DOS_FILE *f;
 226         DOS_FS *fs;
 227         u_int   size, clus;
 228         int     err = 0;
 229
 230         /* Allocate mount structure, associate with open */
 231         fs = alloc(sizeof(DOS_FS));
 232
 233         if ((err = dos_mount(fs, fd)))
 234                 goto out;
 235
 236         if ((err = namede(fs, path, &de)))
 237                 goto out;
 238
 239         clus = stclus(fs->fatsz, de);
 240         size = getulong(de->deFileSize);
 241
 242         if ((!(de->deAttributes & ATTR_DIRECTORY) && (!clus != !size)) ||
 243             ((de->deAttributes & ATTR_DIRECTORY) && size) ||
 244             (clus && !okclus(fs, clus))) {
 245                 err = EINVAL;
 246                 goto out;
 247         }
 248
 249         f = alloc(sizeof(DOS_FILE));
 250 #ifdef BOOTXX
 251         /* due to __internal_memset_ causing all sorts of register spillage
 252            (and being completely unoptimized for zeroing small amounts of
 253            memory), if we hand-initialize the remaining members of f to zero,
 254            the code size drops 68 bytes. This makes no sense, admittedly. */
 255         f->offset = 0;
 256         f->c = 0;
 257 #else
 258         (void)memset(f, 0, sizeof(DOS_FILE));
 259 #endif
 260         f->fs = fs;
 261         fs->links++;
 262         f->de = *de;
 263         fd->f_fsdata = (void *)f;
 264         fsmod = "msdos";
 265
 266 out:
 267         return err;
 268 }
 269
 270 /*
 271  * Read from file
 272  */
 273 __compactcall int
 274 dosfs_read(struct open_file *fd, void *vbuf, size_t nbyte, size_t *resid)
 275 {
 276         off_t   size;
 277         u_int8_t *buf = vbuf;
 278         u_int   nb, off, clus, c, cnt, n;
 279         DOS_FILE *f = (DOS_FILE *)fd->f_fsdata;
 280         int     err = 0;
 281
 282         nb = (u_int) nbyte;
 283         if ((size = fsize(f->fs, &f->de)) == -1)
 284                 return EINVAL;
 285         if (nb > (n = size - f->offset))
 286                 nb = n;
 287         off = f->offset;
 288         if ((clus = stclus(f->fs->fatsz, &f->de)))
 289                 off &= f->fs->bsize - 1;
 290         c = f->c;
 291         cnt = nb;
 292         while (cnt) {
 293                 n = 0;
 294                 if (!c) {
 295                         if ((c = clus))
 296                                 n = bytblk(f->fs, f->offset);
 297                 } else if (!off) {
 298                         n++;
 299                 }
 300                 while (n--) {
 301                         if ((err = fatget(f->fs, &c)))
 302                                 goto out;
 303                         if (!okclus(f->fs, c)) {
 304                                 err = EINVAL;
 305                                 goto out;
 306                         }
 307                 }
 308                 if (!clus || (n = f->fs->bsize - off) > cnt)
 309                         n = cnt;
 310                 if ((err = ioread(f->fs, (c ? blkoff(f->fs, c) :
 311                                 secbyt(f->fs->lsndir)) + off,
 312                             buf, n)))
 313                         goto out;
 314                 f->offset += n;
 315                 f->c = c;
 316                 off = 0;
 317                 buf += n;
 318                 cnt -= n;
 319         }
 320 out:
 321         if (resid)
 322                 *resid = nbyte - nb + cnt;
 323         return err;
 324 }
 325
 326 #ifndef LIBSA_NO_FS_WRITE
 327 /*
 328  * Not implemented.
 329  */
 330 __compactcall int
 331 dosfs_write(struct open_file *fd, void *start, size_t size, size_t *resid)
 332 {
 333
 334         return EROFS;
 335 }
 336 #endif /* !LIBSA_NO_FS_WRITE */
 337
 338 #ifndef LIBSA_NO_FS_SEEK
 339 /*
 340  * Reposition within file
 341  */
 342 __compactcall off_t
 343 dosfs_seek(struct open_file *fd, off_t offset, int whence)
 344 {
 345         off_t   off;
 346         u_int   size;
 347         DOS_FILE *f = (DOS_FILE *)fd->f_fsdata;
 348
 349         size = getulong(f->de.deFileSize);
 350         switch (whence) {
 351         case SEEK_SET:
 352                 off = 0;
 353                 break;
 354         case SEEK_CUR:
 355                 off = f->offset;
 356                 break;
 357         case SEEK_END:
 358                 off = size;
 359                 break;
 360         default:
 361                 return -1;
 362         }
 363         off += offset;
 364         if (off < 0 || off > size)
 365                 return -1;
 366         f->offset = (u_int) off;
 367         f->c = 0;
 368         return off;
 369 }
 370 #endif /* !LIBSA_NO_FS_SEEK */
 371
 372 #ifndef LIBSA_NO_FS_CLOSE
 373 /*
 374  * Close open file
 375  */
 376 __compactcall int
 377 dosfs_close(struct open_file *fd)
 378 {
 379         DOS_FILE *f = (DOS_FILE *)fd->f_fsdata;
 380         DOS_FS *fs = f->fs;
 381
 382         f->fs->links--;
 383         dealloc(f, sizeof(DOS_FILE));
 384         dos_unmount(fs);
 385         return 0;
 386 }
 387 #endif /* !LIBSA_NO_FS_CLOSE */
 388
 389 /*
 390  * Return some stat information on a file.
 391  */
 392 __compactcall int
 393 dosfs_stat(struct open_file *fd, struct stat *sb)
 394 {
 395         DOS_FILE *f = (DOS_FILE *)fd->f_fsdata;
 396
 397         /* only important stuff */
 398         sb->st_mode = (f->de.deAttributes & ATTR_DIRECTORY) ?
 399             (S_IFDIR | 0555) : (S_IFREG | 0444);
 400         sb->st_nlink = 1;
 401         sb->st_uid = 0;
 402         sb->st_gid = 0;
 403         if ((sb->st_size = fsize(f->fs, &f->de)) == -1)
 404                 return EINVAL;
 405         return 0;
 406 }
 407
 408 #if defined(LIBSA_ENABLE_LS_OP)
 409 __compactcall void
 410 dosfs_ls(struct open_file *f, const char *pattern,
 411                 void (*funcp)(char* arg), char* path)
 412 {
 413         printf("Currently ls command is unsupported by dosfs\n");
 414         return;
 415 }
 416 #endif
 417
 418 /*
 419  * Parse DOS boot sector
 420  */
 421 static int
 422 parsebs(DOS_FS *fs, DOS_BS *bs)
 423 {
 424         u_int   sc;
 425
 426         if ((bs->jmp[0] != 0x69 &&
 427                 bs->jmp[0] != 0xe9 &&
 428                 (bs->jmp[0] != 0xeb || bs->jmp[2] != 0x90)) ||
 429             bs->bpb.bpbMedia < 0xf0)
 430                 return EINVAL;
 431         if (getushort(bs->bpb.bpbBytesPerSec) != SECSIZ)
 432                 return EINVAL;
 433         if (!(fs->spc = bs->bpb.bpbSecPerClust) || fs->spc & (fs->spc - 1))
 434                 return EINVAL;
 435         fs->bsize = secbyt(fs->spc);
 436         fs->bshift = ffs(fs->bsize) - 1;
 437         if ((fs->spf = getushort(bs->bpb.bpbFATsecs))) {
 438                 if (bs->bpb.bpbFATs != 2)
 439                         return EINVAL;
 440                 if (!(fs->dirents = getushort(bs->bpb.bpbRootDirEnts)))
 441                         return EINVAL;
 442         } else {
 443                 if (!(fs->spf = getulong(bs->bpb.bpbBigFATsecs)))
 444                         return EINVAL;
 445                 if (!bs->bpb.bpbFATs || bs->bpb.bpbFATs > 16)
 446                         return EINVAL;
 447                 if ((fs->rdcl = getulong(bs->bpb.bpbRootClust)) < LOCLUS)
 448                         return EINVAL;
 449         }
 450         if (!(fs->lsnfat = getushort(bs->bpb.bpbResSectors)))
 451                 return EINVAL;
 452         fs->lsndir = fs->lsnfat + fs->spf * bs->bpb.bpbFATs;
 453         fs->lsndta = fs->lsndir + entsec(fs->dirents);
 454         if (!(sc = getushort(bs->bpb.bpbSectors)) &&
 455             !(sc = getulong(bs->bpb.bpbHugeSectors)))
 456                 return EINVAL;
 457         if (fs->lsndta > sc)
 458                 return EINVAL;
 459         if ((fs->xclus = secblk(fs, sc - fs->lsndta) + 1) < LOCLUS)
 460                 return EINVAL;
 461         fs->fatsz = fs->dirents ? fs->xclus < 0xff6 ? 12 : 16 : 32;
 462         sc = (secbyt(fs->spf) << 1) / (fs->fatsz >> 2) - 1;
 463         if (fs->xclus > sc)
 464                 fs->xclus = sc;
 465         return 0;
 466 }
 467
 468 /*
 469  * Return directory entry from path
 470  */
 471 static int
 472 namede(DOS_FS *fs, const char *path, const struct direntry **dep)
 473 {
 474         char    name[256];
 475         const struct direntry *de;
 476         char   *s;
 477         size_t  n;
 478         int     err;
 479
 480         err = 0;
 481         de = dot;
 482         if (*path == '/')
 483                 path++;
 484         while (*path) {
 485                 if (!(s = strchr(path, '/')))
 486                         s = strchr(path, 0);
 487                 if ((n = s - path) > 255)
 488                         return ENAMETOOLONG;
 489                 memcpy(name, path, n);
 490                 name[n] = 0;
 491                 path = s;
 492                 if (!(de->deAttributes & ATTR_DIRECTORY))
 493                         return ENOTDIR;
 494                 if ((err = lookup(fs, stclus(fs->fatsz, de), name, &de)))
 495                         return err;
 496                 if (*path == '/')
 497                         path++;
 498         }
 499         *dep = de;
 500         return 0;
 501 }
 502
 503 /*
 504  * Lookup path segment
 505  */
 506 static int
 507 lookup(DOS_FS *fs, u_int clus, const char *name, const struct direntry **dep)
 508 {
 509         static DOS_DIR *dir = NULL;
 510         u_char  lfn[261];
 511         u_char  sfn[13];
 512         u_int   nsec, lsec, xdn, chk, sec, ent, x;
 513         int     err = 0, ok, i;
 514
 515         if (!clus)
 516                 for (ent = 0; ent < 2; ent++)
 517                         if (!strcasecmp(name, dotstr[ent])) {
 518                                 *dep = dot + ent;
 519                                 return 0;
 520                         }
 521
 522         if (dir == NULL) {
 523                 dir = alloc(sizeof(DOS_DIR) * DEPSEC);
 524                 if (dir == NULL)
 525                         return ENOMEM;
 526         }
 527
 528         if (!clus && fs->fatsz == 32)
 529                 clus = fs->rdcl;
 530         nsec = !clus ? entsec(fs->dirents) : fs->spc;
 531         lsec = 0;
 532         xdn = chk = 0;
 533         for (;;) {
 534                 if (!clus && !lsec)
 535                         lsec = fs->lsndir;
 536                 else if (okclus(fs, clus))
 537                         lsec = blklsn(fs, clus);
 538                 else {
 539                         err = EINVAL;
 540                         goto out;
 541                 }
 542                 for (sec = 0; sec < nsec; sec++) {
 543                         if ((err = ioget(fs->fd, lsec + sec, dir, 1)))
 544                                 goto out;
 545                         for (ent = 0; ent < DEPSEC; ent++) {
 546                                 if (!*dir[ent].de.deName) {
 547                                         err = ENOENT;
 548                                         goto out;
 549                                 }
 550                                 if (*dir[ent].de.deName != 0xe5) {
 551                                         if (dir[ent].de.deAttributes ==
 552                                             ATTR_WIN95) {
 553                                                 x = dir[ent].xde.weCnt;
 554                                                 if (x & WIN_LAST ||
 555                                                     (x + 1 == xdn &&
 556                                                      dir[ent].xde.weChksum ==
 557                                                      chk)) {
 558                                                         if (x & WIN_LAST) {
 559                                                                 chk = dir[ent].xde.weChksum;
 560                                                                 x &= WIN_CNT;
 561                                                         }
 562                                                         if (x >= 1 && x <= 20) {
 563                                                                 cp_xdnm(lfn, &dir[ent].xde);
 564                                                                 xdn = x;
 565                                                                 continue;
 566                                                         }
 567                                                 }
 568                                         } else if (!(dir[ent].de.deAttributes &
 569                                                      ATTR_VOLUME)) {
 570                                                 if ((ok = xdn == 1)) {
 571                                                         for (x = 0, i = 0;
 572                                                              i < 11; i++)
 573                                                                 x = ((((x & 1) << 7) | (x >> 1)) +
 574                                                                     msdos_dirchar(&dir[ent].de,i)) & 0xff;
 575                                                         ok = chk == x &&
 576                                                             !strcasecmp(name, (const char *)lfn);
 577                                                 }
 578                                                 if (!ok) {
 579                                                         cp_sfn(sfn, &dir[ent].de);
 580                                                         ok = !strcasecmp(name, (const char *)sfn);
 581                                                 }
 582                                                 if (ok) {
 583                                                         *dep = &dir[ent].de;
 584                                                         goto out2;
 585                                                 }
 586                                         }
 587                                 }
 588                                 xdn = 0;
 589                         }
 590                 }
 591                 if (!clus)
 592                         break;
 593                 if ((err = fatget(fs, &clus)))
 594                         goto out;
 595                 if (fatend(fs->fatsz, clus))
 596                         break;
 597         }
 598         err = ENOENT;
 599  out:
 600         dealloc(dir, sizeof(DOS_DIR) * DEPSEC);
 601         dir = NULL;
 602  out2:
 603         return err;
 604 }
 605
 606 /*
 607  * Copy name from extended directory entry
 608  */
 609 static void
 610 cp_xdnm(u_char *lfn, struct winentry *xde)
 611 {
 612         static const struct {
 613                 u_int   off;
 614                 u_int   dim;
 615         } ix[3] = {
 616                 { offsetof(struct winentry, wePart1),
 617                     sizeof(xde->wePart1) / 2 },
 618                 { offsetof(struct winentry, wePart2),
 619                     sizeof(xde->wePart2) / 2 },
 620                 { offsetof(struct winentry, wePart3),
 621                     sizeof(xde->wePart3) / 2 }
 622         };
 623         u_char *p;
 624         u_int   n, x, c;
 625
 626         lfn += 13 * ((xde->weCnt & WIN_CNT) - 1);
 627         for (n = 0; n < 3; n++)
 628                 for (p = (u_char *)xde + ix[n].off, x = ix[n].dim; x;
 629                     p += 2, x--) {
 630                         if ((c = getushort(p)) && (c < 32 || c > 127))
 631                                 c = '?';
 632                         if (!(*lfn++ = c))
 633                                 return;
 634                 }
 635         if (xde->weCnt & WIN_LAST)
 636                 *lfn = 0;
 637 }
 638
 639 /*
 640  * Copy short filename
 641  */
 642 static void
 643 cp_sfn(u_char *sfn, struct direntry *de)
 644 {
 645         u_char *p;
 646         int     j, i;
 647
 648         p = sfn;
 649         if (*de->deName != ' ') {
 650                 for (j = 7; de->deName[j] == ' '; j--);
 651                 for (i = 0; i <= j; i++)
 652                         *p++ = de->deName[i];
 653                 if (*de->deExtension != ' ') {
 654                         *p++ = '.';
 655                         for (j = 2; de->deExtension[j] == ' '; j--);
 656                         for (i = 0; i <= j; i++)
 657                                 *p++ = de->deExtension[i];
 658                 }
 659         }
 660         *p = 0;
 661         if (*sfn == 5)
 662                 *sfn = 0xe5;
 663 }
 664
 665 /*
 666  * Return size of file in bytes
 667  */
 668 static  off_t
 669 fsize(DOS_FS *fs, struct direntry *de)
 670 {
 671         u_long  size;
 672         u_int   c;
 673         int     n;
 674
 675         if (!(size = getulong(de->deFileSize)) &&
 676             de->deAttributes & ATTR_DIRECTORY) {
 677                 if (!(c = getushort(de->deStartCluster))) {
 678                         size = fs->dirents * sizeof(struct direntry);
 679                 } else {
 680                         if ((n = fatcnt(fs, c)) == -1)
 681                                 return n;
 682                         size = blkbyt(fs, n);
 683                 }
 684         }
 685         return size;
 686 }
 687
 688 /*
 689  * Count number of clusters in chain
 690  */
 691 static int
 692 fatcnt(DOS_FS *fs, u_int c)
 693 {
 694         int     n;
 695
 696         for (n = 0; okclus(fs, c); n++)
 697                 if (fatget(fs, &c))
 698                         return -1;
 699         return fatend(fs->fatsz, c) ? n : -1;
 700 }
 701
 702 /*
 703  * Get next cluster in cluster chain
 704  */
 705 static int
 706 fatget(DOS_FS *fs, u_int *c)
 707 {
 708         u_char  buf[4];
 709         u_int   x;
 710         int     err;
 711
 712         err = ioread(fs, secbyt(fs->lsnfat) + fatoff(fs->fatsz, *c), buf,
 713             fs->fatsz != 32 ? 2 : 4);
 714         if (err)
 715                 return err;
 716         x = fs->fatsz != 32 ? getushort(buf) : getulong(buf);
 717         *c = fs->fatsz == 12 ? *c & 1 ? x >> 4 : x & 0xfff : x;
 718         return 0;
 719 }
 720
 721 /*
 722  * Is cluster an end-of-chain marker?
 723  */
 724 static int
 725 fatend(u_int sz, u_int c)
 726 {
 727         return c > (sz == 12 ? 0xff7U : sz == 16 ? 0xfff7U : 0xffffff7);
 728 }
 729
 730 /*
 731  * Offset-based I/O primitive
 732  */
 733 static int
 734 ioread(DOS_FS *fs, u_int offset, void *buf, u_int nbyte)
 735 {
 736         char   *s;
 737         u_int   off, n;
 738         int     err;
 739
 740         s = buf;
 741         if ((off = offset & (SECSIZ - 1))) {
 742                 offset -= off;
 743                 if ((err = iobuf(fs, bytsec(offset))))
 744                         return err;
 745                 offset += SECSIZ;
 746                 if ((n = SECSIZ - off) > nbyte)
 747                         n = nbyte;
 748                 memcpy(s, fs->buf + off, n);
 749                 s += n;
 750                 nbyte -= n;
 751         }
 752         n = nbyte & (SECSIZ - 1);
 753         if (nbyte -= n) {
 754                 if ((err = ioget(fs->fd, bytsec(offset), s, bytsec(nbyte))))
 755                         return err;
 756                 offset += nbyte;
 757                 s += nbyte;
 758         }
 759         if (n) {
 760                 if ((err = iobuf(fs, bytsec(offset))))
 761                         return err;
 762                 memcpy(s, fs->buf, n);
 763         }
 764         return 0;
 765 }
 766
 767 /*
 768  * Buffered sector-based I/O primitive
 769  */
 770 static int
 771 iobuf(DOS_FS *fs, u_int lsec)
 772 {
 773         int     err;
 774
 775         if (fs->bufsec != lsec) {
 776                 if ((err = ioget(fs->fd, lsec, fs->buf, 1)))
 777                         return err;
 778                 fs->bufsec = lsec;
 779         }
 780         return 0;
 781 }
 782
 783 /*
 784  * Sector-based I/O primitive
 785  */
 786 static int
 787 ioget(struct open_file *fd, u_int lsec, void *buf, u_int nsec)
 788 {
 789         size_t rsize;
 790         int err;
 791
 792 #ifndef LIBSA_NO_TWIDDLE
 793         twiddle();
 794 #endif
 795         err = DEV_STRATEGY(fd->f_dev)(fd->f_devdata, F_READ, lsec,
 796             secbyt(nsec), buf, &rsize);
 797         return err;
 798 }