sys/lib/libsa/dosfs.c

   1 /*      $NetBSD: dosfs.c,v 1.20 2014/03/20 03:13:18 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 #include "ls.h"
 410 __compactcall void
 411 dosfs_ls(struct open_file *f, const char *pattern)
 412 {
 413         lsunsup("dosfs");
 414 }
 415
 416 #if defined(__minix) && defined(LIBSA_ENABLE_LOAD_MODS_OP)
 417 __compactcall void
 418 dosfs_load_mods(struct open_file *f, const char *pattern,
 419         void (*funcp)(char *), char *path)
 420 {
 421         load_modsunsup("dosfs");
 422 }
 423 #endif /* defined(__minix) && defined(LIBSA_ENABLE_LOAD_MODS_OP) */
 424 #endif
 425
 426 /*
 427  * Parse DOS boot sector
 428  */
 429 static int
 430 parsebs(DOS_FS *fs, DOS_BS *bs)
 431 {
 432         u_int   sc;
 433
 434         if ((bs->jmp[0] != 0x69 &&
 435                 bs->jmp[0] != 0xe9 &&
 436                 (bs->jmp[0] != 0xeb || bs->jmp[2] != 0x90)) ||
 437             bs->bpb.bpbMedia < 0xf0)
 438                 return EINVAL;
 439         if (getushort(bs->bpb.bpbBytesPerSec) != SECSIZ)
 440                 return EINVAL;
 441         if (!(fs->spc = bs->bpb.bpbSecPerClust) || fs->spc & (fs->spc - 1))
 442                 return EINVAL;
 443         fs->bsize = secbyt(fs->spc);
 444         fs->bshift = ffs(fs->bsize) - 1;
 445         if ((fs->spf = getushort(bs->bpb.bpbFATsecs))) {
 446                 if (bs->bpb.bpbFATs != 2)
 447                         return EINVAL;
 448                 if (!(fs->dirents = getushort(bs->bpb.bpbRootDirEnts)))
 449                         return EINVAL;
 450         } else {
 451                 if (!(fs->spf = getulong(bs->bpb.bpbBigFATsecs)))
 452                         return EINVAL;
 453                 if (!bs->bpb.bpbFATs || bs->bpb.bpbFATs > 16)
 454                         return EINVAL;
 455                 if ((fs->rdcl = getulong(bs->bpb.bpbRootClust)) < LOCLUS)
 456                         return EINVAL;
 457         }
 458         if (!(fs->lsnfat = getushort(bs->bpb.bpbResSectors)))
 459                 return EINVAL;
 460         fs->lsndir = fs->lsnfat + fs->spf * bs->bpb.bpbFATs;
 461         fs->lsndta = fs->lsndir + entsec(fs->dirents);
 462         if (!(sc = getushort(bs->bpb.bpbSectors)) &&
 463             !(sc = getulong(bs->bpb.bpbHugeSectors)))
 464                 return EINVAL;
 465         if (fs->lsndta > sc)
 466                 return EINVAL;
 467         if ((fs->xclus = secblk(fs, sc - fs->lsndta) + 1) < LOCLUS)
 468                 return EINVAL;
 469         fs->fatsz = fs->dirents ? fs->xclus < 0xff6 ? 12 : 16 : 32;
 470         sc = (secbyt(fs->spf) << 1) / (fs->fatsz >> 2) - 1;
 471         if (fs->xclus > sc)
 472                 fs->xclus = sc;
 473         return 0;
 474 }
 475
 476 /*
 477  * Return directory entry from path
 478  */
 479 static int
 480 namede(DOS_FS *fs, const char *path, const struct direntry **dep)
 481 {
 482         char    name[256];
 483         const struct direntry *de;
 484         char   *s;
 485         size_t  n;
 486         int     err;
 487
 488         err = 0;
 489         de = dot;
 490         if (*path == '/')
 491                 path++;
 492         while (*path) {
 493                 if (!(s = strchr(path, '/')))
 494                         s = strchr(path, 0);
 495                 if ((n = s - path) > 255)
 496                         return ENAMETOOLONG;
 497                 memcpy(name, path, n);
 498                 name[n] = 0;
 499                 path = s;
 500                 if (!(de->deAttributes & ATTR_DIRECTORY))
 501                         return ENOTDIR;
 502                 if ((err = lookup(fs, stclus(fs->fatsz, de), name, &de)))
 503                         return err;
 504                 if (*path == '/')
 505                         path++;
 506         }
 507         *dep = de;
 508         return 0;
 509 }
 510
 511 /*
 512  * Lookup path segment
 513  */
 514 static int
 515 lookup(DOS_FS *fs, u_int clus, const char *name, const struct direntry **dep)
 516 {
 517         static DOS_DIR *dir = NULL;
 518         u_char  lfn[261];
 519         u_char  sfn[13];
 520         u_int   nsec, lsec, xdn, chk, sec, ent, x;
 521         int     err = 0, ok, i;
 522
 523         if (!clus)
 524                 for (ent = 0; ent < 2; ent++)
 525                         if (!strcasecmp(name, dotstr[ent])) {
 526                                 *dep = dot + ent;
 527                                 return 0;
 528                         }
 529
 530         if (dir == NULL) {
 531                 dir = alloc(sizeof(DOS_DIR) * DEPSEC);
 532                 if (dir == NULL)
 533                         return ENOMEM;
 534         }
 535
 536         if (!clus && fs->fatsz == 32)
 537                 clus = fs->rdcl;
 538         nsec = !clus ? entsec(fs->dirents) : fs->spc;
 539         lsec = 0;
 540         xdn = chk = 0;
 541         for (;;) {
 542                 if (!clus && !lsec)
 543                         lsec = fs->lsndir;
 544                 else if (okclus(fs, clus))
 545                         lsec = blklsn(fs, clus);
 546                 else {
 547                         err = EINVAL;
 548                         goto out;
 549                 }
 550                 for (sec = 0; sec < nsec; sec++) {
 551                         if ((err = ioget(fs->fd, lsec + sec, dir, 1)))
 552                                 goto out;
 553                         for (ent = 0; ent < DEPSEC; ent++) {
 554                                 if (!*dir[ent].de.deName) {
 555                                         err = ENOENT;
 556                                         goto out;
 557                                 }
 558                                 if (*dir[ent].de.deName != 0xe5) {
 559                                         if (dir[ent].de.deAttributes ==
 560                                             ATTR_WIN95) {
 561                                                 x = dir[ent].xde.weCnt;
 562                                                 if (x & WIN_LAST ||
 563                                                     (x + 1 == xdn &&
 564                                                      dir[ent].xde.weChksum ==
 565                                                      chk)) {
 566                                                         if (x & WIN_LAST) {
 567                                                                 chk = dir[ent].xde.weChksum;
 568                                                                 x &= WIN_CNT;
 569                                                         }
 570                                                         if (x >= 1 && x <= 20) {
 571                                                                 cp_xdnm(lfn, &dir[ent].xde);
 572                                                                 xdn = x;
 573                                                                 continue;
 574                                                         }
 575                                                 }
 576                                         } else if (!(dir[ent].de.deAttributes &
 577                                                      ATTR_VOLUME)) {
 578                                                 if ((ok = xdn == 1)) {
 579                                                         for (x = 0, i = 0;
 580                                                              i < 11; i++)
 581                                                                 x = ((((x & 1) << 7) | (x >> 1)) +
 582                                                                     msdos_dirchar(&dir[ent].de,i)) & 0xff;
 583                                                         ok = chk == x &&
 584                                                             !strcasecmp(name, (const char *)lfn);
 585                                                 }
 586                                                 if (!ok) {
 587                                                         cp_sfn(sfn, &dir[ent].de);
 588                                                         ok = !strcasecmp(name, (const char *)sfn);
 589                                                 }
 590                                                 if (ok) {
 591                                                         *dep = &dir[ent].de;
 592                                                         goto out2;
 593                                                 }
 594                                         }
 595                                 }
 596                                 xdn = 0;
 597                         }
 598                 }
 599                 if (!clus)
 600                         break;
 601                 if ((err = fatget(fs, &clus)))
 602                         goto out;
 603                 if (fatend(fs->fatsz, clus))
 604                         break;
 605         }
 606         err = ENOENT;
 607  out:
 608         dealloc(dir, sizeof(DOS_DIR) * DEPSEC);
 609         dir = NULL;
 610  out2:
 611         return err;
 612 }
 613
 614 /*
 615  * Copy name from extended directory entry
 616  */
 617 static void
 618 cp_xdnm(u_char *lfn, struct winentry *xde)
 619 {
 620         static const struct {
 621                 u_int   off;
 622                 u_int   dim;
 623         } ix[3] = {
 624                 { offsetof(struct winentry, wePart1),
 625                     sizeof(xde->wePart1) / 2 },
 626                 { offsetof(struct winentry, wePart2),
 627                     sizeof(xde->wePart2) / 2 },
 628                 { offsetof(struct winentry, wePart3),
 629                     sizeof(xde->wePart3) / 2 }
 630         };
 631         u_char *p;
 632         u_int   n, x, c;
 633
 634         lfn += 13 * ((xde->weCnt & WIN_CNT) - 1);
 635         for (n = 0; n < 3; n++)
 636                 for (p = (u_char *)xde + ix[n].off, x = ix[n].dim; x;
 637                     p += 2, x--) {
 638                         if ((c = getushort(p)) && (c < 32 || c > 127))
 639                                 c = '?';
 640                         if (!(*lfn++ = c))
 641                                 return;
 642                 }
 643         if (xde->weCnt & WIN_LAST)
 644                 *lfn = 0;
 645 }
 646
 647 /*
 648  * Copy short filename
 649  */
 650 static void
 651 cp_sfn(u_char *sfn, struct direntry *de)
 652 {
 653         u_char *p;
 654         int     j, i;
 655
 656         p = sfn;
 657         if (*de->deName != ' ') {
 658                 for (j = 7; de->deName[j] == ' '; j--);
 659                 for (i = 0; i <= j; i++)
 660                         *p++ = de->deName[i];
 661                 if (*de->deExtension != ' ') {
 662                         *p++ = '.';
 663                         for (j = 2; de->deExtension[j] == ' '; j--);
 664                         for (i = 0; i <= j; i++)
 665                                 *p++ = de->deExtension[i];
 666                 }
 667         }
 668         *p = 0;
 669         if (*sfn == 5)
 670                 *sfn = 0xe5;
 671 }
 672
 673 /*
 674  * Return size of file in bytes
 675  */
 676 static  off_t
 677 fsize(DOS_FS *fs, struct direntry *de)
 678 {
 679         u_long  size;
 680         u_int   c;
 681         int     n;
 682
 683         if (!(size = getulong(de->deFileSize)) &&
 684             de->deAttributes & ATTR_DIRECTORY) {
 685                 if (!(c = getushort(de->deStartCluster))) {
 686                         size = fs->dirents * sizeof(struct direntry);
 687                 } else {
 688                         if ((n = fatcnt(fs, c)) == -1)
 689                                 return n;
 690                         size = blkbyt(fs, n);
 691                 }
 692         }
 693         return size;
 694 }
 695
 696 /*
 697  * Count number of clusters in chain
 698  */
 699 static int
 700 fatcnt(DOS_FS *fs, u_int c)
 701 {
 702         int     n;
 703
 704         for (n = 0; okclus(fs, c); n++)
 705                 if (fatget(fs, &c))
 706                         return -1;
 707         return fatend(fs->fatsz, c) ? n : -1;
 708 }
 709
 710 /*
 711  * Get next cluster in cluster chain
 712  */
 713 static int
 714 fatget(DOS_FS *fs, u_int *c)
 715 {
 716         u_char  buf[4];
 717         u_int   x;
 718         int     err;
 719
 720         err = ioread(fs, secbyt(fs->lsnfat) + fatoff(fs->fatsz, *c), buf,
 721             fs->fatsz != 32 ? 2 : 4);
 722         if (err)
 723                 return err;
 724         x = fs->fatsz != 32 ? getushort(buf) : getulong(buf);
 725         *c = fs->fatsz == 12 ? *c & 1 ? x >> 4 : x & 0xfff : x;
 726         return 0;
 727 }
 728
 729 /*
 730  * Is cluster an end-of-chain marker?
 731  */
 732 static int
 733 fatend(u_int sz, u_int c)
 734 {
 735         return c > (sz == 12 ? 0xff7U : sz == 16 ? 0xfff7U : 0xffffff7);
 736 }
 737
 738 /*
 739  * Offset-based I/O primitive
 740  */
 741 static int
 742 ioread(DOS_FS *fs, u_int offset, void *buf, u_int nbyte)
 743 {
 744         char   *s;
 745         u_int   off, n;
 746         int     err;
 747
 748         s = buf;
 749         if ((off = offset & (SECSIZ - 1))) {
 750                 offset -= off;
 751                 if ((err = iobuf(fs, bytsec(offset))))
 752                         return err;
 753                 offset += SECSIZ;
 754                 if ((n = SECSIZ - off) > nbyte)
 755                         n = nbyte;
 756                 memcpy(s, fs->buf + off, n);
 757                 s += n;
 758                 nbyte -= n;
 759         }
 760         n = nbyte & (SECSIZ - 1);
 761         if (nbyte -= n) {
 762                 if ((err = ioget(fs->fd, bytsec(offset), s, bytsec(nbyte))))
 763                         return err;
 764                 offset += nbyte;
 765                 s += nbyte;
 766         }
 767         if (n) {
 768                 if ((err = iobuf(fs, bytsec(offset))))
 769                         return err;
 770                 memcpy(s, fs->buf, n);
 771         }
 772         return 0;
 773 }
 774
 775 /*
 776  * Buffered sector-based I/O primitive
 777  */
 778 static int
 779 iobuf(DOS_FS *fs, u_int lsec)
 780 {
 781         int     err;
 782
 783         if (fs->bufsec != lsec) {
 784                 if ((err = ioget(fs->fd, lsec, fs->buf, 1)))
 785                         return err;
 786                 fs->bufsec = lsec;
 787         }
 788         return 0;
 789 }
 790
 791 /*
 792  * Sector-based I/O primitive
 793  */
 794 static int
 795 ioget(struct open_file *fd, u_int lsec, void *buf, u_int nsec)
 796 {
 797         size_t rsize;
 798         int err;
 799
 800 #ifndef LIBSA_NO_TWIDDLE
 801         twiddle();
 802 #endif
 803         err = DEV_STRATEGY(fd->f_dev)(fd->f_devdata, F_READ, lsec,
 804             secbyt(nsec), buf, &rsize);
 805         return err;
 806 }